open-agents-ai 0.103.6 → 0.103.8

package/dist/index.js

@@ -28448,7 +28448,77 @@ function buildDirTree(root, maxDepth, prefix = "", depth = 0) {
   }
   return result;
 }
-var OA_DIR, SUBDIRS, CONTEXT_FILES, PENDING_TASK_FILE, CONTEXT_SAVE_FILE, MAX_CONTEXT_ENTRIES, SKIP_DIRS;
+function loadUsageFile(filePath) {
+  try {
+    if (existsSync28(filePath)) {
+      return JSON.parse(readFileSync20(filePath, "utf-8"));
+    }
+  } catch {
+  }
+  return { records: [] };
+}
+function saveUsageFile(filePath, data) {
+  const dir = join38(filePath, "..");
+  mkdirSync9(dir, { recursive: true });
+  writeFileSync9(filePath, JSON.stringify(data, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+}
+function recordUsage(kind, value, opts) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const update = (filePath) => {
+    const data = loadUsageFile(filePath);
+    const existing = data.records.find((r) => r.kind === kind && r.value === value);
+    if (existing) {
+      existing.useCount++;
+      existing.lastUsed = now;
+      if (opts?.meta)
+        existing.meta = { ...existing.meta, ...opts.meta };
+    } else {
+      data.records.push({
+        value,
+        kind,
+        useCount: 1,
+        firstUsed: now,
+        lastUsed: now,
+        meta: opts?.meta
+      });
+    }
+    if (data.records.length > MAX_HISTORY_RECORDS) {
+      data.records.sort((a, b) => new Date(b.lastUsed).getTime() - new Date(a.lastUsed).getTime());
+      data.records = data.records.slice(0, MAX_HISTORY_RECORDS);
+    }
+    saveUsageFile(filePath, data);
+  };
+  update(join38(homedir9(), ".open-agents", USAGE_HISTORY_FILE));
+  if (opts?.repoRoot) {
+    update(join38(opts.repoRoot, OA_DIR, USAGE_HISTORY_FILE));
+  }
+}
+function loadUsageHistory(kind, repoRoot) {
+  const globalPath = join38(homedir9(), ".open-agents", USAGE_HISTORY_FILE);
+  const globalData = loadUsageFile(globalPath);
+  const localData = repoRoot ? loadUsageFile(join38(repoRoot, OA_DIR, USAGE_HISTORY_FILE)) : { records: [] };
+  const map = /* @__PURE__ */ new Map();
+  for (const r of globalData.records) {
+    if (r.kind !== kind)
+      continue;
+    map.set(r.value, { ...r, localUses: 0 });
+  }
+  for (const r of localData.records) {
+    if (r.kind !== kind)
+      continue;
+    const existing = map.get(r.value);
+    if (existing) {
+      existing.localUses = r.useCount;
+      if (new Date(r.lastUsed) > new Date(existing.lastUsed)) {
+        existing.lastUsed = r.lastUsed;
+      }
+    } else {
+      map.set(r.value, { ...r, localUses: r.useCount });
+    }
+  }
+  return Array.from(map.values()).sort((a, b) => new Date(b.lastUsed).getTime() - new Date(a.lastUsed).getTime());
+}
+var OA_DIR, SUBDIRS, CONTEXT_FILES, PENDING_TASK_FILE, CONTEXT_SAVE_FILE, MAX_CONTEXT_ENTRIES, SKIP_DIRS, USAGE_HISTORY_FILE, MAX_HISTORY_RECORDS;
 var init_oa_directory = __esm({
   "packages/cli/dist/tui/oa-directory.js"() {
     "use strict";
@@ -28486,6 +28556,8 @@ var init_oa_directory = __esm({
       ".idea",
       ".vscode"
     ]);
+    USAGE_HISTORY_FILE = "usage-history.json";
+    MAX_HISTORY_RECORDS = 50;
   }
 });
 
@@ -30014,46 +30086,102 @@ function ansi3(code, text) {
 function fg2562(code, text) {
   return isTTY3 ? `\x1B[38;5;${code}m${text}\x1B[0m` : text;
 }
+function stripAnsi(s) {
+  return s.replace(/\x1B\[[0-9;]*m/g, "");
+}
 function defaultRenderRow(item, focused, isActive) {
   const marker = isActive ? selectColors.green("\u25CF") : focused ? selectColors.orange("\u25CF") : selectColors.dim("\u25CB");
   const label = focused ? selectColors.orange(selectColors.bold(item.label)) : isActive ? selectColors.green(item.label) : item.label;
   const detail = item.detail ? `  ${selectColors.dim(item.detail)}` : "";
   return `  ${marker} ${label}${detail}`;
 }
+function matchRow(item, focused, isActive) {
+  if (focused || isActive) {
+    return defaultRenderRow(item, focused, isActive);
+  }
+  const marker = selectColors.matchLight("\u25CB");
+  const label = selectColors.matchLight(stripAnsi(item.label));
+  const detail = item.detail ? `  ${selectColors.dim(stripAnsi(item.detail))}` : "";
+  return `  ${marker} ${label}${detail}`;
+}
 function tuiSelect(opts) {
   const { items, title, rl } = opts;
   const renderRow = opts.renderRow ?? defaultRenderRow;
   const activeKey = opts.activeKey ?? null;
+  const skipSet = new Set(opts.skipKeys ?? []);
   if (items.length === 0) {
     return Promise.resolve({ confirmed: false, key: null, index: -1 });
   }
-  let cursor = activeKey ? items.findIndex((i) => i.key === activeKey) : 0;
-  if (cursor < 0)
-    cursor = 0;
+  const isSkippable = (idx) => skipSet.has(items[idx].key);
+  let filter = "";
+  let matchSet = /* @__PURE__ */ new Set();
+  function updateFilter() {
+    if (!filter) {
+      matchSet = new Set(items.map((_, i) => i));
+    } else {
+      const lower = filter.toLowerCase();
+      matchSet = /* @__PURE__ */ new Set();
+      for (let i = 0; i < items.length; i++) {
+        if (isSkippable(i))
+          continue;
+        const plain = stripAnsi(items[i].label).toLowerCase();
+        const detailPlain = items[i].detail ? stripAnsi(items[i].detail).toLowerCase() : "";
+        if (plain.includes(lower) || detailPlain.includes(lower)) {
+          matchSet.add(i);
+        }
+      }
+    }
+  }
+  updateFilter();
+  const findSelectable = (from, dir) => {
+    let idx = from;
+    while (idx >= 0 && idx < items.length) {
+      if (!isSkippable(idx) && matchSet.has(idx))
+        return idx;
+      idx += dir;
+    }
+    return -1;
+  };
+  let cursor = activeKey ? items.findIndex((i) => i.key === activeKey) : -1;
+  if (cursor < 0 || isSkippable(cursor)) {
+    const first = findSelectable(0, 1);
+    cursor = first >= 0 ? first : 0;
+  }
   const termRows = process.stdout.rows ?? 24;
-  const maxVisible = opts.maxVisible ?? Math.max(5, termRows - 6);
-  let scrollOffset = Math.max(0, cursor - Math.floor(maxVisible / 2));
+  const overhead = 6;
+  const maxVisible = opts.maxVisible ?? Math.max(3, termRows - overhead);
+  let scrollOffset = 0;
   let lastRenderedLines = 0;
   return new Promise((resolve31) => {
     const stdin = process.stdin;
     const hadRawMode = stdin.isRaw;
+    const savedRlListeners = [];
     if (rl) {
       rl.pause();
+      for (const event of ["keypress", "data"]) {
+        const listeners = stdin.listeners(event);
+        for (const fn of listeners) {
+          savedRlListeners.push({ event, fn });
+          stdin.removeListener(event, fn);
+        }
+      }
     }
     if (typeof stdin.setRawMode === "function") {
       stdin.setRawMode(true);
     }
     stdin.resume();
     process.stdout.write("\x1B[?25l");
-    function clampScroll() {
-      if (cursor < scrollOffset) {
-        scrollOffset = cursor;
-      } else if (cursor >= scrollOffset + maxVisible) {
-        scrollOffset = cursor - maxVisible + 1;
-      }
-      scrollOffset = Math.max(0, Math.min(items.length - maxVisible, scrollOffset));
-      if (scrollOffset < 0)
-        scrollOffset = 0;
+    function clampScroll(displayList) {
+      const cursorPos = displayList.indexOf(cursor);
+      if (cursorPos < 0)
+        return;
+      if (cursorPos < scrollOffset) {
+        scrollOffset = cursorPos;
+      } else if (cursorPos >= scrollOffset + maxVisible) {
+        scrollOffset = cursorPos - maxVisible + 1;
+      }
+      const maxOffset = Math.max(0, displayList.length - maxVisible);
+      scrollOffset = Math.max(0, Math.min(maxOffset, scrollOffset));
     }
     function render() {
       if (lastRenderedLines > 0) {
@@ -30063,29 +30191,66 @@ function tuiSelect(opts) {
         }
         process.stdout.write(`\x1B[${lastRenderedLines}A`);
       }
-      clampScroll();
       const lines = [];
       if (title) {
         lines.push(`
   ${selectColors.bold(title)}`);
-        lines.push("");
       }
-      if (scrollOffset > 0) {
-        lines.push(`  ${selectColors.dim(`  \u25B2 ${scrollOffset} more`)}`);
+      if (filter) {
+        const count = matchSet.size;
+        lines.push(`  ${selectColors.cyan("/")} ${selectColors.bold(filter)} ${selectColors.dim(`(${count} match${count !== 1 ? "es" : ""})`)}`);
+      } else {
+        lines.push(`  ${selectColors.dim("Type to filter...")}`);
       }
-      const visibleEnd = Math.min(items.length, scrollOffset + maxVisible);
-      for (let i = scrollOffset; i < visibleEnd; i++) {
-        const item = items[i];
-        const focused = i === cursor;
+      lines.push("");
+      let displayList;
+      if (filter) {
+        displayList = [];
+        for (let i = 0; i < items.length; i++) {
+          if (matchSet.has(i) || isSkippable(i)) {
+            displayList.push(i);
+          }
+        }
+        displayList = displayList.filter((idx, pos) => {
+          if (!isSkippable(idx))
+            return true;
+          for (let j = pos + 1; j < displayList.length; j++) {
+            if (!isSkippable(displayList[j]))
+              return true;
+            break;
+          }
+          return false;
+        });
+      } else {
+        displayList = items.map((_, i) => i);
+      }
+      clampScroll(displayList);
+      const visibleStart = scrollOffset;
+      const visibleEnd = Math.min(displayList.length, scrollOffset + maxVisible);
+      if (visibleStart > 0) {
+        lines.push(`  ${selectColors.dim(`  \u25B2 ${visibleStart} more`)}`);
+      }
+      for (let vi = visibleStart; vi < visibleEnd; vi++) {
+        const idx = displayList[vi];
+        const item = items[idx];
+        if (isSkippable(idx)) {
+          lines.push(`  ${item.label}`);
+          continue;
+        }
+        const focused = idx === cursor;
         const isActive = item.key === activeKey;
-        lines.push(renderRow(item, focused, isActive));
+        if (filter) {
+          lines.push(matchRow(item, focused, isActive));
+        } else {
+          lines.push(renderRow(item, focused, isActive));
+        }
       }
-      const remaining = items.length - visibleEnd;
+      const remaining = displayList.length - visibleEnd;
       if (remaining > 0) {
         lines.push(`  ${selectColors.dim(`  \u25BC ${remaining} more`)}`);
       }
       lines.push("");
-      lines.push(`  ${selectColors.dim("\u2191/\u2193 navigate  Enter select  Esc cancel")}`);
+      lines.push(`  ${selectColors.dim("\u2191/\u2193 navigate  Enter select  Esc " + (filter ? "clear filter" : "cancel") + "  Type to filter")}`);
       lines.push("");
       const output = lines.join("\n");
       process.stdout.write(output);
@@ -30093,6 +30258,7 @@ function tuiSelect(opts) {
     }
     function cleanup() {
       stdin.removeListener("data", onData);
+      process.stdout.removeListener("resize", onResize);
       process.stdout.write("\x1B[?25h");
       if (lastRenderedLines > 0) {
         process.stdout.write(`\x1B[${lastRenderedLines}A`);
@@ -30104,6 +30270,9 @@ function tuiSelect(opts) {
       if (typeof stdin.setRawMode === "function") {
         stdin.setRawMode(hadRawMode ?? false);
       }
+      for (const { event, fn } of savedRlListeners) {
+        stdin.on(event, fn);
+      }
       if (rl) {
         rl.resume();
         rl.prompt(false);
@@ -30111,29 +30280,93 @@ function tuiSelect(opts) {
     }
     function onData(chunk) {
       const seq = chunk.toString("utf8");
-      if (seq === "\x1B[A" || seq === "k") {
-        cursor = Math.max(0, cursor - 1);
-        render();
-      } else if (seq === "\x1B[B" || seq === "j") {
-        cursor = Math.min(items.length - 1, cursor + 1);
-        render();
-      } else if (seq === "\x1B[H" || seq === "g") {
-        cursor = 0;
+      if (seq === "\x1B[A") {
+        const next = findSelectable(cursor - 1, -1);
+        if (next >= 0 && next !== cursor) {
+          cursor = next;
+          render();
+        }
+      } else if (seq === "\x1B[B") {
+        const next = findSelectable(cursor + 1, 1);
+        if (next >= 0 && next !== cursor) {
+          cursor = next;
+          render();
+        }
+      } else if (seq === "\x1B[5~") {
+        for (let i = 0; i < maxVisible; i++) {
+          const next = findSelectable(cursor - 1, -1);
+          if (next < 0 || next === cursor)
+            break;
+          cursor = next;
+        }
         render();
-      } else if (seq === "\x1B[F" || seq === "G") {
-        cursor = items.length - 1;
+      } else if (seq === "\x1B[6~") {
+        for (let i = 0; i < maxVisible; i++) {
+          const next = findSelectable(cursor + 1, 1);
+          if (next < 0 || next === cursor)
+            break;
+          cursor = next;
+        }
         render();
+      } else if (seq === "\x1B[H") {
+        const first = findSelectable(0, 1);
+        if (first >= 0) {
+          cursor = first;
+          render();
+        }
+      } else if (seq === "\x1B[F") {
+        const last = findSelectable(items.length - 1, -1);
+        if (last >= 0) {
+          cursor = last;
+          render();
+        }
       } else if (seq === "\r" || seq === "\n") {
-        cleanup();
-        resolve31({ confirmed: true, key: items[cursor].key, index: cursor });
-      } else if (seq === "\x1B" || seq === "\x1B\x1B" || seq === "q") {
-        cleanup();
-        resolve31({ confirmed: false, key: null, index: cursor });
+        if (!isSkippable(cursor) && matchSet.has(cursor)) {
+          cleanup();
+          resolve31({ confirmed: true, key: items[cursor].key, index: cursor });
+        }
+      } else if (seq === "\x1B" || seq === "\x1B\x1B") {
+        if (filter) {
+          filter = "";
+          updateFilter();
+          const valid = findSelectable(cursor, 1);
+          if (valid >= 0)
+            cursor = valid;
+          scrollOffset = 0;
+          render();
+        } else {
+          cleanup();
+          resolve31({ confirmed: false, key: null, index: cursor });
+        }
       } else if (seq === "") {
         cleanup();
         resolve31({ confirmed: false, key: null, index: cursor });
+      } else if (seq === "\x7F" || seq === "\b") {
+        if (filter.length > 0) {
+          filter = filter.slice(0, -1);
+          updateFilter();
+          if (!matchSet.has(cursor) || isSkippable(cursor)) {
+            const next = findSelectable(0, 1);
+            if (next >= 0)
+              cursor = next;
+          }
+          scrollOffset = 0;
+          render();
+        }
+      } else if (seq.length === 1 && seq.charCodeAt(0) >= 32 && seq.charCodeAt(0) < 127) {
+        filter += seq;
+        updateFilter();
+        if (matchSet.size > 0) {
+          const first = findSelectable(0, 1);
+          if (first >= 0)
+            cursor = first;
+        }
+        scrollOffset = 0;
+        render();
       }
     }
+    const onResize = () => render();
+    process.stdout.on("resize", onResize);
     stdin.on("data", onData);
     render();
   });
@@ -30148,7 +30381,11 @@ var init_tui_select = __esm({
       green: (t) => ansi3("32", t),
       dim: (t) => ansi3("2", t),
       bold: (t) => ansi3("1", t),
-      cyan: (t) => ansi3("36", t)
+      cyan: (t) => ansi3("36", t),
+      /** Lighter grey for filter matches (252 = near-white) */
+      matchLight: (t) => fg2562(252, t),
+      /** Dark grey for non-matching items (240 = dark grey) */
+      matchDark: (t) => fg2562(240, t)
     };
   }
 });
@@ -31274,16 +31511,39 @@ async function showModelPicker(ctx, local = false) {
       renderWarning("No models found.");
       return;
     }
-    const items = models.map((m) => ({
-      key: m.name,
-      label: m.name,
-      detail: [m.parameterSize, m.size, m.modified].filter(Boolean).join("  ")
-    }));
+    const items = [];
+    const history = loadUsageHistory("model", ctx.repoRoot);
+    const liveModelNames = new Set(models.map((m) => m.name));
+    if (history.length > 0) {
+      items.push({ key: "__header_recent__", label: c2.dim("\u2500\u2500 Recent \u2500\u2500"), detail: "" });
+      for (const h of history.slice(0, 8)) {
+        const uses = h.localUses > 0 ? `${h.useCount} uses (${h.localUses} local)` : `${h.useCount} uses`;
+        const available = liveModelNames.has(h.value) ? "" : c2.yellow(" [offline]");
+        items.push({
+          key: h.value,
+          label: h.value,
+          detail: `${uses}${available}`
+        });
+      }
+      items.push({ key: "__header_available__", label: c2.dim("\u2500\u2500 Available \u2500\u2500"), detail: "" });
+    }
+    const historyKeys = new Set(history.map((h) => h.value));
+    for (const m of models) {
+      if (history.length > 0 && historyKeys.has(m.name))
+        continue;
+      items.push({
+        key: m.name,
+        label: m.name,
+        detail: [m.parameterSize, m.size, m.modified].filter(Boolean).join("  ")
+      });
+    }
     const result = await tuiSelect({
       items,
       activeKey: ctx.config.model,
       title: "Select Model",
-      rl: ctx.rl
+      rl: ctx.rl,
+      // Skip header rows
+      skipKeys: ["__header_recent__", "__header_available__"]
     });
     if (!result.confirmed || !result.key) {
       renderInfo("Model selection cancelled.");
@@ -31296,6 +31556,30 @@ async function showModelPicker(ctx, local = false) {
 }
 async function handleEndpoint(arg, ctx, local = false) {
   if (!arg) {
+    const history = loadUsageHistory("endpoint", ctx.repoRoot);
+    if (history.length > 0) {
+      const items = history.map((h) => {
+        const provider2 = h.meta?.provider ?? detectProvider(h.value).label;
+        const uses = h.localUses > 0 ? `${h.useCount} uses (${h.localUses} local)` : `${h.useCount} uses`;
+        return {
+          key: h.value,
+          label: h.value,
+          detail: `${provider2}  ${uses}`
+        };
+      });
+      const result = await tuiSelect({
+        items,
+        activeKey: ctx.config.backendUrl,
+        title: "Select Endpoint",
+        rl: ctx.rl
+      });
+      if (result.confirmed && result.key) {
+        await handleEndpoint(result.key, ctx, local);
+        return;
+      }
+      renderInfo("Endpoint selection cancelled.");
+      return;
+    }
     const currentProvider = detectProvider(ctx.config.backendUrl);
     process.stdout.write(`
   ${c2.bold("Current endpoint:")}
@@ -31399,6 +31683,15 @@ async function handleEndpoint(arg, ctx, local = false) {
     }
     ctx.saveSettings(endpointSettings);
   }
+  recordUsage("endpoint", normalizedUrl, {
+    repoRoot: local ? ctx.repoRoot : void 0,
+    local,
+    meta: {
+      provider: provider.label,
+      backendType,
+      ...apiKey ? { authHint: apiKey.slice(0, 4) + "..." } : {}
+    }
+  });
   process.stdout.write(`
   ${c2.green("\u2714")} Endpoint updated and saved${local ? " (project-local)" : ""}:
 `);
@@ -31715,6 +32008,14 @@ async function switchModel(query, ctx, local = false) {
     if (local) {
       renderInfo("Saved as project-local override.");
     }
+    recordUsage("model", finalModel, {
+      repoRoot: local ? ctx.repoRoot : void 0,
+      local,
+      meta: {
+        endpoint: ctx.config.backendUrl,
+        parameterSize: match.parameterSize ?? ""
+      }
+    });
     if (ctx.setContextWindowSize) {
       const ctxSize = await queryContextSize(ctx.config.backendUrl, finalModel, ctx.config.apiKey);
       if (ctxSize) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.103.6",
+  "version": "0.103.8",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",