opencode-rag-plugin 1.17.3 → 1.18.1

package/dist/web/api.d.ts

@@ -4,6 +4,7 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { LanceDbStore } from "../vectorstore/lancedb.js";
 import { KeywordIndex } from "../retriever/keyword-index.js";
+import type { RagConfig } from "../core/config.js";
 /** Internal shape for a JSON API response: an HTTP status code and a serialisable body. */
 interface ApiResponse {
     status: number;
@@ -23,9 +24,10 @@ interface ApiResponse {
  * @param keywordIndex - The keyword-index instance for text search.
  * @param storePath    - Filesystem path to the store directory (used by eval endpoints).
  * @param cwd          - Optional workspace root for resolving file paths.
+ * @param cfg          - Active RAG configuration (used by quirk endpoints).
  * @returns An async handler that returns `true` when a route matched or `false` otherwise.
  */
-export declare function createApiHandler(store: LanceDbStore, keywordIndex: KeywordIndex, storePath: string, cwd?: string): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
+export declare function createApiHandler(store: LanceDbStore, keywordIndex: KeywordIndex, storePath: string, cwd?: string, cfg?: RagConfig): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
 /**
  * Perform token-usage analysis for a single evaluation session.
  *

package/dist/web/api.js

@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
 import { extname, resolve as resolvePathModule } from "node:path";
 import { listSessions, getSession, deleteSession, compareSessions, validateSessionID } from "../eval/storage.js";
 import { analyzeTokenUsage, compareTokenAnalyses, projectTokenSavings } from "../eval/token-analysis.js";
+import { listQuirks, lintQuirks, removeQuirk } from "../quirks/quirk-store.js";
 const FILE_MIME_TYPES = {
     ".png": "image/png",
     ".jpg": "image/jpeg",
@@ -11,6 +12,13 @@ const FILE_MIME_TYPES = {
     ".bmp": "image/bmp",
     ".svg": "image/svg+xml",
 };
+/** No-op embedder used by quirk endpoints that never need to embed text in the read-only UI context. */
+const stubEmbedder = {
+    name: "stub",
+    embed: async () => {
+        throw new Error("Embedder is not available in the Web UI context");
+    },
+};
 /** Split a raw URL into its pathname and parsed query-string parameters. */
 function parseQuery(url) {
     const [path, queryString] = url.split("?");
@@ -43,13 +51,22 @@ function sendJson(res, response) {
  * @param keywordIndex - The keyword-index instance for text search.
  * @param storePath    - Filesystem path to the store directory (used by eval endpoints).
  * @param cwd          - Optional workspace root for resolving file paths.
+ * @param cfg          - Active RAG configuration (used by quirk endpoints).
  * @returns An async handler that returns `true` when a route matched or `false` otherwise.
  */
-export function createApiHandler(store, keywordIndex, storePath, cwd) {
+export function createApiHandler(store, keywordIndex, storePath, cwd, cfg) {
     return async (req, res) => {
         const url = req.url ?? "/";
         const method = req.method ?? "GET";
         const { path, params } = parseQuery(url);
+        // Quirk store dependencies (embedder is a no-op stub for the read-only UI context).
+        const quirkDeps = {
+            embedder: stubEmbedder,
+            store,
+            keywordIndex,
+            cfg: cfg ?? {},
+            storePath,
+        };
         // CORS preflight
         if (method === "OPTIONS") {
             res.writeHead(204, {
@@ -143,6 +160,22 @@ export function createApiHandler(store, keywordIndex, storePath, cwd) {
                 const body = await readBody(req);
                 response = handleEvalProjectSavings(body);
             }
+            // Quirk memory endpoints
+            else if (path === "/api/quirks" && method === "GET") {
+                response = await handleQuirks(quirkDeps);
+            }
+            else if (path === "/api/quirks/lint" && method === "GET") {
+                response = await handleQuirkLint(quirkDeps);
+            }
+            else if (path.startsWith("/api/quirks/") && method === "DELETE") {
+                const id = path.slice("/api/quirks/".length);
+                if (!id) {
+                    response = { status: 400, body: { error: "Missing quirk ID" } };
+                }
+                else {
+                    response = await handleQuirkDelete(quirkDeps, id);
+                }
+            }
             else {
                 return false;
             }
@@ -181,6 +214,22 @@ async function handleFiles(store) {
     const files = await store.listFiles();
     return { status: 200, body: files };
 }
+// ── Quirk Memory API ─────────────────────────────────────────────────
+/** Respond with all stored quirks, sorted by last-observed time (most recent first). */
+async function handleQuirks(deps) {
+    const quirks = await listQuirks(deps);
+    return { status: 200, body: { quirks } };
+}
+/** Respond with the health-check issues for the quirk store (confidence, staleness, duplicates). */
+async function handleQuirkLint(deps) {
+    const issues = await lintQuirks(deps);
+    return { status: 200, body: { issues } };
+}
+/** Delete a single quirk by its ID from the store, index, and audit log. */
+async function handleQuirkDelete(deps, id) {
+    await removeQuirk(deps, id);
+    return { status: 200, body: { deleted: true, id } };
+}
 /**
  * Respond with a paginated, optionally filtered list of chunks.
  *

package/dist/web/server.d.ts

@@ -15,6 +15,7 @@ export interface WebUiServer {
  * @param port            - TCP port to listen on.
  * @param cwd             - Optional workspace root used to resolve file paths for the file API.
  * @param vectorDimension - Embedding vector dimension (default 384).
+ * @param cfg             - Active RAG configuration (used by quirk endpoints).
  * @returns A {@link WebUiServer} handle for the running server.
  */
-export declare function startWebUi(storePath: string, port: number, cwd?: string, vectorDimension?: number): Promise<WebUiServer>;
+export declare function startWebUi(storePath: string, port: number, cwd?: string, vectorDimension?: number, cfg?: import("../core/config.js").RagConfig): Promise<WebUiServer>;

package/dist/web/server.js

@@ -53,13 +53,14 @@ function serveUiAsset(res, filePath) {
  * @param port            - TCP port to listen on.
  * @param cwd             - Optional workspace root used to resolve file paths for the file API.
  * @param vectorDimension - Embedding vector dimension (default 384).
+ * @param cfg             - Active RAG configuration (used by quirk endpoints).
  * @returns A {@link WebUiServer} handle for the running server.
  */
-export async function startWebUi(storePath, port, cwd, vectorDimension = 384) {
+export async function startWebUi(storePath, port, cwd, vectorDimension = 384, cfg) {
     const store = new LanceDbStore(storePath, vectorDimension);
     const keywordIndex = await KeywordIndex.load(storePath);
     const html = getStaticHtml();
-    const apiHandler = createApiHandler(store, keywordIndex, storePath, cwd);
+    const apiHandler = createApiHandler(store, keywordIndex, storePath, cwd, cfg);
     const server = createServer(async (req, res) => {
         const url = req.url ?? "/";
         if (url === "/" || url === "/index.html") {

package/dist/web/ui/index.html

@@ -24,6 +24,7 @@
       <button id="nav-chunks" class="nav-btn px-3 py-1 rounded text-sm font-medium hover:bg-slate-700 transition">Chunks</button>
       <button id="nav-files" class="nav-btn px-3 py-1 rounded text-sm font-medium hover:bg-slate-700 transition">Files</button>
       <button id="nav-evaluate" class="nav-btn px-3 py-1 rounded text-sm font-medium hover:bg-slate-700 transition">Evaluate</button>
+      <button id="nav-quirks" class="nav-btn px-3 py-1 rounded text-sm font-medium hover:bg-slate-700 transition">Quirks</button>
     </nav>
     <div class="flex-1"></div>
     <div class="relative">
@@ -56,6 +57,7 @@
       </div>
       <div id="view-files" class="h-full overflow-y-auto scrollbar-thin"></div>
       <div id="view-evaluate" class="hidden h-full flex flex-col"></div>
+      <div id="view-quirks" class="hidden h-full overflow-y-auto scrollbar-thin"></div>
     </main>
   </div>
 
@@ -85,6 +87,9 @@
       async evalAnalysis(id) { const r = await fetch('/api/eval/sessions/' + encodeURIComponent(id) + '/analysis'); return r.json(); },
       async evalTokenCompare(a, b) { const p = new URLSearchParams({a, b}); const r = await fetch('/api/eval/token-compare?' + p); return r.json(); },
       async evalProjectSavings(params) { const r = await fetch('/api/eval/project-savings', { method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify(params) }); return r.json(); },
+      async quirks() { const r = await fetch('/api/quirks'); return r.json(); },
+      async quirkLint() { const r = await fetch('/api/quirks/lint'); return r.json(); },
+      async deleteQuirk(id) { const r = await fetch('/api/quirks/' + encodeURIComponent(id), { method: 'DELETE' }); return r.json(); },
     };
 
     const state = {
@@ -101,6 +106,8 @@
       currentChunks: [],
       evalSelectedSessions: new Set(),
       evalSessionDetail: null,
+
+      quirkTypeFilter: null,
     };
 
     function $(sel) { return document.querySelector(sel); }
@@ -131,6 +138,21 @@
       return `<span class="inline-block px-1.5 py-0.5 rounded text-xs font-mono ${langColor(lang)} bg-slate-800">${lang}</span>`;
     }
 
+    function quirkTypeColor(quirkType) {
+      const map = {
+        gotcha: 'text-amber-400',
+        preference: 'text-emerald-400',
+        decision: 'text-sky-400',
+        'environment-constraint': 'text-rose-400',
+      };
+      return map[quirkType] || 'text-slate-400';
+    }
+
+    function quirkTypeBadge(quirkType) {
+      const label = quirkType || 'general';
+      return `<span class="inline-block px-1.5 py-0.5 rounded text-xs font-mono ${quirkTypeColor(quirkType)} bg-slate-800">${label}</span>`;
+    }
+
     function truncate(s, len=80) {
       if (!s) return '';
       return s.length > len ? s.slice(0, len) + '...' : s;
@@ -794,6 +816,8 @@
 
     $('#nav-evaluate')?.addEventListener('click', () => { showView('evaluate'); renderEvaluate(); });
 
+    $('#nav-quirks')?.addEventListener('click', () => { showView('quirks'); renderQuirks(); });
+
     // ── Evaluate View ──────────────────────────────────────────────────
 
     function formatTokens(n) {
@@ -1468,6 +1492,145 @@
       }
     }
 
+    // ── Quirks View ────────────────────────────────────────────────────
+
+    function confidenceColor(c) {
+      if (c >= 0.75) return 'text-green-400';
+      if (c >= 0.5) return 'text-amber-400';
+      return 'text-red-400';
+    }
+
+    function formatQuirkDate(iso) {
+      if (!iso) return '-';
+      const d = new Date(iso);
+      if (isNaN(d.getTime())) return '-';
+      return d.toLocaleDateString() + ' ' + d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    }
+
+    async function renderQuirks() {
+      const el = $('#view-quirks');
+      if (!el) return;
+      el.innerHTML = '<div class="text-center py-10 text-slate-500">Loading quirks...</div>';
+
+      let data;
+      try {
+        data = await API.quirks();
+      } catch (err) {
+        el.innerHTML = `<div class="text-center py-10 text-red-400">Failed to load quirks: ${escapeHtml(String(err))}</div>`;
+        return;
+      }
+
+      const quirks = data.quirks || [];
+      const types = [...new Set(quirks.map(q => q.quirkType || 'general'))].sort();
+      const filter = state.quirkTypeFilter;
+
+      const filtered = filter ? quirks.filter(q => (q.quirkType || 'general') === filter) : quirks;
+
+      if (quirks.length === 0) {
+        el.innerHTML = `
+          <div class="text-center flex-1 flex items-center justify-center py-20">
+            <div>
+              <div class="text-4xl mb-3">&#128161;</div>
+              <h2 class="text-lg font-semibold text-slate-400 mb-2">No quirks stored yet</h2>
+              <p class="text-sm text-slate-500 max-w-md mx-auto">
+                Quirks are experiential memories (gotchas, preferences, decisions, environment constraints)
+                recorded by the agent via the <code>add_quirk</code> tool. They will appear here once captured.
+              </p>
+            </div>
+          </div>`;
+        return;
+      }
+
+      el.innerHTML = `
+        <div class="flex items-center gap-3 mb-4">
+          <h2 class="text-lg font-semibold text-white">Quirks</h2>
+          <span class="text-sm text-slate-400">${quirks.length} total${filter ? `, ${filtered.length} shown` : ''}</span>
+          <div class="flex-1"></div>
+          <div class="flex items-center gap-2">
+            <button class="quirk-filter px-2 py-1 rounded text-xs ${!filter ? 'bg-brand-600 text-white' : 'bg-slate-700 text-slate-300 hover:bg-slate-600'}" data-type="">All</button>
+            ${types.map(t => `
+              <button class="quirk-filter px-2 py-1 rounded text-xs ${filter === t ? 'bg-brand-600 text-white' : 'bg-slate-700 text-slate-300 hover:bg-slate-600'}" data-type="${escapeHtml(t)}">${escapeHtml(t)}</button>
+            `).join('')}
+          </div>
+          <button id="quirk-lint-btn" class="px-3 py-1 bg-slate-700 rounded text-sm hover:bg-slate-600">Lint</button>
+        </div>
+        <div id="quirk-lint-area" class="hidden mb-4"></div>
+        <div class="grid grid-cols-1 lg:grid-cols-2 gap-3">
+          ${filtered.map(q => `
+            <div class="bg-slate-900 rounded-lg border border-slate-700 p-3 flex flex-col" data-id="${escapeHtml(q.id)}">
+              <div class="flex items-center gap-2 mb-2">
+                ${quirkTypeBadge(q.quirkType)}
+                <span class="text-xs text-slate-500">confidence <span class="${confidenceColor(q.confidence)}">${((q.confidence ?? 1) * 100).toFixed(0)}%</span></span>
+                <span class="text-xs text-slate-600 ml-auto">${formatQuirkDate(q.lastObserved)}</span>
+              </div>
+              <p class="text-sm text-slate-200 whitespace-pre-wrap flex-1">${escapeHtml(q.content)}</p>
+              ${q.tags && q.tags.length ? `
+                <div class="flex flex-wrap gap-1 mt-2">
+                  ${q.tags.map(t => `<span class="inline-block px-1.5 py-0.5 rounded text-xs bg-slate-800 text-slate-400">#${escapeHtml(t)}</span>`).join('')}
+                </div>` : ''}
+              ${q.sourceRef ? `<div class="text-xs text-slate-600 mt-2 font-mono">src: ${escapeHtml(q.sourceRef)}</div>` : ''}
+              <div class="flex items-center justify-between mt-2 pt-2 border-t border-slate-800">
+                <span class="text-xs text-slate-600 font-mono">${escapeHtml(q.id)}</span>
+                <button class="quirk-delete text-xs text-slate-600 hover:text-red-400" data-id="${escapeHtml(q.id)}">Delete</button>
+              </div>
+            </div>
+          `).join('')}
+        </div>
+      `;
+
+      $$('.quirk-filter').forEach(btn => {
+        btn.addEventListener('click', () => {
+          state.quirkTypeFilter = btn.dataset.type || null;
+          renderQuirks();
+        });
+      });
+
+      $$('.quirk-delete').forEach(btn => {
+        btn.addEventListener('click', async (e) => {
+          e.stopPropagation();
+          const id = btn.dataset.id;
+          if (!confirm('Delete this quirk? This cannot be undone.')) return;
+          btn.textContent = 'Deleting...';
+          try {
+            await API.deleteQuirk(id);
+            renderQuirks();
+          } catch (err) {
+            alert('Failed to delete quirk: ' + String(err));
+            renderQuirks();
+          }
+        });
+      });
+
+      $('#quirk-lint-btn')?.addEventListener('click', async () => {
+        const area = $('#quirk-lint-area');
+        if (!area) return;
+        if (!area.classList.contains('hidden')) {
+          area.classList.add('hidden');
+          area.innerHTML = '';
+          return;
+        }
+        area.classList.remove('hidden');
+        area.innerHTML = '<div class="text-center py-3 text-slate-500">Running lint...</div>';
+        try {
+          const res = await API.quirkLint();
+          const issues = res.issues || [];
+          if (issues.length === 0) {
+            area.innerHTML = `<div class="bg-green-900/20 border border-green-800 rounded-lg p-3 text-sm text-green-300">All quirks look healthy. No issues found.</div>`;
+          } else {
+            area.innerHTML = `
+              <div class="bg-slate-900 rounded-lg border border-amber-800 p-3">
+                <div class="text-sm font-semibold text-amber-300 mb-2">${issues.length} issue(s) found</div>
+                <ul class="space-y-1 text-xs text-slate-300 list-disc list-inside">
+                  ${issues.map(i => `<li>${escapeHtml(i)}</li>`).join('')}
+                </ul>
+              </div>`;
+          }
+        } catch (err) {
+          area.innerHTML = `<div class="bg-red-900/20 border border-red-800 rounded-lg p-3 text-sm text-red-300">Lint failed: ${escapeHtml(String(err))}</div>`;
+        }
+      });
+    }
+
     // Init
     renderDashboard();
   </script>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-rag-plugin",
-  "version": "1.17.3",
+  "version": "1.18.1",
   "description": "OpenCode plugin for local-first RAG-based semantic code search",
   "type": "module",
   "main": "./dist/plugin-entry.js",