opencode-rag-plugin 1.21.2 → 1.22.0

package/dist/cli/commands/ui.js

@@ -32,7 +32,11 @@ export function registerUiCommand(program) {
             const port = parseInt(options.port ?? String(config.ui?.port ?? 3210), 10);
             const openBrowser = options.open !== false && (config.ui?.openBrowser ?? true);
             const { startWebUi } = await import("../../web/server.js");
-            const server = await startWebUi(storePath, port, cwd, config.embedding.vectorDimension ?? 384, config);
+            const { findConfigFile } = await import("../../core/config.js");
+            const configPath = options.config
+                ? path.resolve(cwd, options.config)
+                : findConfigFile(cwd);
+            const server = await startWebUi(storePath, port, cwd, config.embedding.vectorDimension ?? 384, config, configPath);
             const url = `http://127.0.0.1:${server.port}/?token=${server.token}`;
             logCliInfo(logFilePath, "ui", `\n${c.heading("OpenCodeRAG Web UI")}`);
             logCliInfo(logFilePath, "ui", `  ${c.label("URL:")} ${c.value(url)}`);

package/dist/content/reader.d.ts

@@ -3,7 +3,7 @@
  */
 import type { RagConfig } from "../core/config.js";
 import { type FileManifest } from "../core/manifest.js";
-import { type ExcludeMatcher } from "../core/exclude.js";
+import { type ExcludeMatcher, type IncludedMatcher } from "../core/exclude.js";
 import { DescriptionCache } from "../core/desc-cache.js";
 import { type ImageVisionProvider } from "../chunker/image.js";
 /** Metadata and extracted content for a single workspace file discovered during scanning. */
@@ -28,7 +28,7 @@ interface Logger {
  * Recursively walk a directory tree and collect paths matching the given extension set,
  * respecting exclusion lists and configurable limits for max directories and results.
  */
-export declare function walkFiles(dir: string, extensions: Set<string>, excludeDirs: ExcludeMatcher, excludeFiles?: ExcludeMatcher, rootDir?: string, logger?: Logger, dirCount?: {
+export declare function walkFiles(dir: string, extensions: Set<string>, excludeDirs: ExcludeMatcher, excludeFiles?: ExcludeMatcher, includeDirs?: IncludedMatcher, rootDir?: string, logger?: Logger, dirCount?: {
     value: number;
 }, maxDirs?: number, maxResults?: number): Promise<string[]>;
 /**

package/dist/content/reader.js

@@ -5,7 +5,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import pLimit from "p-limit";
 import { computeFileHash, computeDescriptionConfigHash, normalizeFilePath } from "../core/manifest.js";
-import { createExcludeMatcher } from "../core/exclude.js";
+import { createExcludeMatcher, createIncludeMatcher } from "../core/exclude.js";
 import { DescriptionCache } from "../core/desc-cache.js";
 import { createImageVisionProvider, } from "../chunker/image.js";
 import * as pdfExtractor from "./pdf.js";
@@ -17,13 +17,14 @@ import * as imageExtractor from "./image.js";
  * Recursively walk a directory tree and collect paths matching the given extension set,
  * respecting exclusion lists and configurable limits for max directories and results.
  */
-export async function walkFiles(dir, extensions, excludeDirs, excludeFiles, rootDir = dir, logger, dirCount, maxDirs = 10_000, maxResults = 100_000) {
+export async function walkFiles(dir, extensions, excludeDirs, excludeFiles, includeDirs, rootDir = dir, logger, dirCount, maxDirs = 10_000, maxResults = 100_000) {
     const results = [];
     const entries = await fs.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
         const fullPath = path.join(dir, entry.name);
         if (entry.isDirectory()) {
-            if (excludeDirs.excluded(path.relative(rootDir, fullPath)))
+            const rel = path.relative(rootDir, fullPath);
+            if ((includeDirs && !includeDirs.included(rel)) || excludeDirs.excluded(rel))
                 continue;
             if (dirCount) {
                 dirCount.value++;
@@ -39,7 +40,7 @@ export async function walkFiles(dir, extensions, excludeDirs, excludeFiles, root
                 logger?.warn(`Exceeded ${maxResults} matching files — truncating walk at ${fullPath}`);
                 return results;
             }
-            results.push(...(await walkFiles(fullPath, extensions, excludeDirs, excludeFiles, rootDir, logger, dirCount, maxDirs, maxResults)));
+            results.push(...(await walkFiles(fullPath, extensions, excludeDirs, excludeFiles, includeDirs, rootDir, logger, dirCount, maxDirs, maxResults)));
         }
         else if (entry.isFile()) {
             if (results.length >= maxResults) {
@@ -104,6 +105,7 @@ export async function scanWorkspaceFiles(cwd, config, logger, manifest, filterPa
     }
     const excludeDirMatcher = createExcludeMatcher(config.indexing.excludeDirs);
     const excludeFileMatcher = createExcludeMatcher(config.indexing.excludeFiles ?? []);
+    const includeDirMatcher = createIncludeMatcher(config.indexing.includeDirs ?? []);
     let files;
     if (filterPaths && filterPaths.length > 0) {
         files = filterPaths
@@ -116,14 +118,14 @@ export async function scanWorkspaceFiles(cwd, config, logger, manifest, filterPa
             const rel = path.relative(cwd, fp);
             if (rel.startsWith(".."))
                 return false;
-            return !excludeDirMatcher.excluded(rel) && !excludeFileMatcher.excluded(rel);
+            return includeDirMatcher.included(rel) && !excludeDirMatcher.excluded(rel) && !excludeFileMatcher.excluded(rel);
         });
     }
     else {
         logger?.info("Walking directory tree...");
         const walkStart = Date.now();
         const dirCount = { value: 0 };
-        files = await walkFiles(cwd, extensions, excludeDirMatcher, excludeFileMatcher, cwd, logger, dirCount);
+        files = await walkFiles(cwd, extensions, excludeDirMatcher, excludeFileMatcher, includeDirMatcher, cwd, logger, dirCount);
         const walkSec = ((Date.now() - walkStart) / 1000).toFixed(1);
         logger?.info(`Found ${files.length} matching files in ${walkSec}s (${dirCount.value} dirs traversed)`);
     }

package/dist/core/config.d.ts

@@ -265,6 +265,21 @@ export interface RagConfig {
          * patterns are anchored to the workspace root.
          */
         excludeFiles?: string[];
+        /**
+         * Workspace-relative folder paths to **restrict indexing to**.
+         *
+         * When non-empty, only files inside these folders (and their
+         * subfolders) are indexed; files directly in the workspace root are
+         * NOT indexed. `excludeDirs`/`excludeFiles` still apply inside the
+         * included folders. Empty or omitted = whole workspace (default).
+         *
+         * Semantics:
+         * - Entries are **anchored to the workspace root** (unlike
+         *   `excludeDirs`, plain names do NOT match at any depth).
+         * - Supports globs (`docs/**`, `src/{a,b}`); use `/` as separator
+         *   (converted automatically). Matching is case-insensitive.
+         */
+        includeDirs?: string[];
         /** Number of overlapping lines between adjacent chunks. */
         chunkOverlap: number;
         /** Minimum file size in bytes to index (0 = no minimum). */
@@ -415,3 +430,15 @@ export declare function loadConfig(filePath: string, validate?: boolean): RagCon
  * @param dimension - The vector dimension to persist.
  */
 export declare function persistProbedDimension(configPath: string, dimension: number): void;
+/**
+ * Set a value at a dotted path inside the config JSON file, creating
+ * intermediate objects as needed, and write it back with 2-space
+ * indentation. Reads/writes the raw file, so comments or formatting of
+ * unrelated keys are preserved as parsed (the file is re-serialized).
+ *
+ * @param configPath - Absolute path to the config JSON file.
+ * @param path       - Dotted path segments, e.g. `["indexing", "includeDirs"]`.
+ * @param value      - Value to write at the target path.
+ * @returns `true` when the file was updated, `false` on any error.
+ */
+export declare function updateConfigValue(configPath: string, path: string[], value: unknown): boolean;

package/dist/core/config.js

@@ -617,4 +617,37 @@ export function persistProbedDimension(configPath, dimension) {
         // best-effort
     }
 }
+/**
+ * Set a value at a dotted path inside the config JSON file, creating
+ * intermediate objects as needed, and write it back with 2-space
+ * indentation. Reads/writes the raw file, so comments or formatting of
+ * unrelated keys are preserved as parsed (the file is re-serialized).
+ *
+ * @param configPath - Absolute path to the config JSON file.
+ * @param path       - Dotted path segments, e.g. `["indexing", "includeDirs"]`.
+ * @param value      - Value to write at the target path.
+ * @returns `true` when the file was updated, `false` on any error.
+ */
+export function updateConfigValue(configPath, path, value) {
+    try {
+        let raw = readFileSync(configPath, "utf-8");
+        if (raw.charCodeAt(0) === 0xfeff)
+            raw = raw.slice(1);
+        const data = JSON.parse(raw);
+        let target = data;
+        for (let i = 0; i < path.length - 1; i++) {
+            const key = path[i];
+            if (!target[key] || typeof target[key] !== "object") {
+                target[key] = {};
+            }
+            target = target[key];
+        }
+        target[path[path.length - 1]] = value;
+        writeFileSync(configPath, JSON.stringify(data, null, 2), "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 //# sourceMappingURL=config.js.map

package/dist/core/exclude.d.ts

@@ -1,4 +1,18 @@
 export interface ExcludeMatcher {
     excluded(relPath: string): boolean;
 }
+export interface IncludedMatcher {
+    included(relPath: string): boolean;
+}
 export declare function createExcludeMatcher(patterns: string[]): ExcludeMatcher;
+/**
+ * Create a matcher for `indexing.includeDirs`.
+ *
+ * Semantics differ from {@link createExcludeMatcher}: every pattern is
+ * **anchored to the workspace root** — it is matched as a glob against each
+ * ancestor prefix of the path, so `docs` includes `<root>/docs` and all its
+ * contents, but never a nested `docs` elsewhere in the tree. The workspace
+ * root itself (`""`) is always included so a walk can descend into it.
+ * Empty pattern lists include everything.
+ */
+export declare function createIncludeMatcher(patterns: string[]): IncludedMatcher;

package/dist/core/exclude.js

@@ -42,4 +42,41 @@ export function createExcludeMatcher(patterns) {
     }
     return { excluded };
 }
+/**
+ * Create a matcher for `indexing.includeDirs`.
+ *
+ * Semantics differ from {@link createExcludeMatcher}: every pattern is
+ * **anchored to the workspace root** — it is matched as a glob against each
+ * ancestor prefix of the path, so `docs` includes `<root>/docs` and all its
+ * contents, but never a nested `docs` elsewhere in the tree. The workspace
+ * root itself (`""`) is always included so a walk can descend into it.
+ * Empty pattern lists include everything.
+ */
+export function createIncludeMatcher(patterns) {
+    const matchers = [];
+    for (const pattern of patterns) {
+        const pat = pattern.trim().replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+        if (!pat)
+            continue;
+        matchers.push(new Minimatch(pat, { nocase: true, dot: true }));
+    }
+    if (matchers.length === 0) {
+        return { included: () => true };
+    }
+    function included(relPath) {
+        const normalized = relPath.replace(/\\/g, "/");
+        if (!normalized)
+            return true;
+        let prefix = "";
+        for (const seg of normalized.split("/")) {
+            prefix = prefix ? `${prefix}/${seg}` : seg;
+            for (const mm of matchers) {
+                if (mm.match(prefix) || mm.match(`${prefix}/`))
+                    return true;
+            }
+        }
+        return false;
+    }
+    return { included };
+}
 //# sourceMappingURL=exclude.js.map

package/dist/indexer/watch.d.ts

@@ -28,7 +28,9 @@ export declare function createWatchPassScheduler(runPass: (filterPaths?: string[
 /**
  * Build a predicate that returns `true` for paths that should be ignored by
  * a file watcher (store directory, manifest file, and configured exclude
- * directories).
+ * directories). When `indexing.includeDirs` is non-empty, any path outside
+ * the included folders is ignored as well, so out-of-scope changes never
+ * trigger re-index passes.
  *
  * @param cwd       - Workspace root directory.
  * @param config    - RAG configuration containing `indexing.excludeDirs`.

package/dist/indexer/watch.js

@@ -3,7 +3,7 @@
  */
 import path from "node:path";
 import { manifestPathFor } from "../core/manifest.js";
-import { createExcludeMatcher } from "../core/exclude.js";
+import { createExcludeMatcher, createIncludeMatcher } from "../core/exclude.js";
 /**
  * Create a scheduler that debounces calls to a re-index pass. While a pass is
  * running, subsequent notifications queue a single rerun. Useful for watching
@@ -108,7 +108,9 @@ export function createWatchPassScheduler(runPass, onError, debounceMs = 300) {
 /**
  * Build a predicate that returns `true` for paths that should be ignored by
  * a file watcher (store directory, manifest file, and configured exclude
- * directories).
+ * directories). When `indexing.includeDirs` is non-empty, any path outside
+ * the included folders is ignored as well, so out-of-scope changes never
+ * trigger re-index passes.
  *
  * @param cwd       - Workspace root directory.
  * @param config    - RAG configuration containing `indexing.excludeDirs`.
@@ -120,6 +122,7 @@ export function createWatchIgnore(cwd, config, storePath) {
     const manifestPath = manifestPathFor(storePath);
     const dirMatcher = createExcludeMatcher(config.indexing.excludeDirs);
     const fileMatcher = createExcludeMatcher(config.indexing.excludeFiles ?? []);
+    const includeMatcher = createIncludeMatcher(config.indexing.includeDirs ?? []);
     // Prefix check with a trailing separator so sibling dirs like
     // `<storePath>2` are NOT ignored; case-insensitive on win32 so a
     // differently-cased store path cannot cause self-triggering watch loops.
@@ -136,7 +139,7 @@ export function createWatchIgnore(cwd, config, storePath) {
         const relative = path.relative(cwd, resolved);
         if (!relative || relative.startsWith(".."))
             return false;
-        return dirMatcher.excluded(relative) || fileMatcher.excluded(relative);
+        return !includeMatcher.included(relative) || dirMatcher.excluded(relative) || fileMatcher.excluded(relative);
     };
 }
 //# sourceMappingURL=watch.js.map

package/dist/tui.js

@@ -8,7 +8,7 @@ import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadRuntimeOverrides, saveRuntimeOverride } from "./core/runtime-overrides.js";
 import { PROVIDER_DEFAULTS } from "./core/provider-defaults.js";
-import { loadConfig } from "./core/config.js";
+import { loadConfig, updateConfigValue } from "./core/config.js";
 import { setPendingRagInjection } from "./core/rag-injection-flag.js";
 /** Cached plugin version string from package.json. */
 let _version;
@@ -275,26 +275,6 @@ function resolveProviderBaseUrl(provider) {
  * Write a single config value at a dotted path into the opencode-rag.json file.
  * Creates intermediate objects as needed.
  */
-function saveConfigValue(configPath, path, value) {
-    try {
-        let raw = readFileSync(configPath, "utf-8");
-        if (raw.charCodeAt(0) === 0xfeff)
-            raw = raw.slice(1);
-        const data = JSON.parse(raw);
-        let target = data;
-        for (let i = 0; i < path.length - 1; i++) {
-            const key = path[i];
-            if (!target[key] || typeof target[key] !== "object") {
-                target[key] = {};
-            }
-            target = target[key];
-        }
-        target[path[path.length - 1]] = value;
-        writeFileSync(configPath, JSON.stringify(data, null, 2), "utf-8");
-    }
-    catch {
-    }
-}
 /**
  * Mirror the watcher status file that the server plugin maintains, so the
  * sidebar reflects a watcher toggle from the settings dialog immediately:
@@ -334,12 +314,12 @@ function saveModelSelection(storePath, configPath, selectionValue, path, provide
     const ragProvider = providerIdToRagProvider(providerId);
     const baseUrl = provider ? resolveProviderBaseUrl(provider) : "";
     saveRuntimeOverride(storePath, [section, "provider"], ragProvider);
-    saveConfigValue(configPath, [section, "provider"], ragProvider);
+    updateConfigValue(configPath, [section, "provider"], ragProvider);
     saveRuntimeOverride(storePath, [section, "model"], modelId);
-    saveConfigValue(configPath, [section, "model"], modelId);
+    updateConfigValue(configPath, [section, "model"], modelId);
     if (baseUrl) {
         saveRuntimeOverride(storePath, [section, "baseUrl"], baseUrl);
-        saveConfigValue(configPath, [section, "baseUrl"], baseUrl);
+        updateConfigValue(configPath, [section, "baseUrl"], baseUrl);
     }
     const apiKey = provider?.options?.apiKey ?? "";
     if (apiKey) {
@@ -704,7 +684,7 @@ async function openSettingsDialog(api) {
                 else if (entry.type === "boolean") {
                     const newVal = !entry.currentValue;
                     saveRuntimeOverride(storePath, entry.path, newVal);
-                    saveConfigValue(configPath, entry.path, newVal);
+                    updateConfigValue(configPath, entry.path, newVal);
                     api.ui.toast({
                         variant: "success",
                         title: "Settings",
@@ -730,7 +710,7 @@ async function openSettingsDialog(api) {
                             const num = parseFloat(input);
                             if (!isNaN(num)) {
                                 saveRuntimeOverride(storePath, entry.path, num);
-                                saveConfigValue(configPath, entry.path, num);
+                                updateConfigValue(configPath, entry.path, num);
                                 api.ui.toast({
                                     variant: "success",
                                     title: "Settings",
@@ -763,7 +743,7 @@ async function openSettingsDialog(api) {
                                     return;
                                 }
                                 saveRuntimeOverride(storePath, entry.path, parsed);
-                                saveConfigValue(configPath, entry.path, parsed);
+                                updateConfigValue(configPath, entry.path, parsed);
                                 api.ui.toast({
                                     variant: "success",
                                     title: "Settings",
@@ -792,7 +772,7 @@ async function openSettingsDialog(api) {
                         value: String(entry.currentValue),
                         onConfirm: (input) => {
                             saveRuntimeOverride(storePath, entry.path, input);
-                            saveConfigValue(configPath, entry.path, input);
+                            updateConfigValue(configPath, entry.path, input);
                             api.ui.toast({
                                 variant: "success",
                                 title: "Settings",
@@ -828,7 +808,7 @@ async function openSettingsDialog(api) {
                             }
                             else if (input) {
                                 saveRuntimeOverride(storePath, entry.path, input);
-                                saveConfigValue(configPath, entry.path, input);
+                                updateConfigValue(configPath, entry.path, input);
                                 entry.currentValue = input;
                             }
                             api.onSettingsChanged?.();

package/dist/web/api.d.ts

@@ -4,7 +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";
+import { type RagConfig } from "../core/config.js";
 import { type EmbeddingProvider } from "../core/interfaces.js";
 /** Internal shape for a JSON API response: an HTTP status code and a serialisable body. */
 interface ApiResponse {
@@ -26,9 +26,12 @@ interface ApiResponse {
  * @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).
+ * @param getEmbedder  - Lazily-created embedder for /api/retrieve and reindex passes.
+ * @param token        - Per-run auth token required on every request.
+ * @param configPath   - Path to the opencode-rag.json config file, used by PUT /api/config.
  * @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, cfg?: RagConfig, getEmbedder?: () => Promise<EmbeddingProvider>, token?: string): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
+export declare function createApiHandler(store: LanceDbStore, keywordIndex: KeywordIndex, storePath: string, cwd?: string, cfg?: RagConfig, getEmbedder?: () => Promise<EmbeddingProvider>, token?: string, configPath?: string): (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
 /**
  * Perform token-usage analysis for a single evaluation session.
  *

package/dist/web/api.js

@@ -1,10 +1,12 @@
-import { readFileSync, statSync } from "node:fs";
+import { readFileSync, readdirSync, statSync } from "node:fs";
 import { extname, join, resolve as resolvePathModule } from "node:path";
 import { createHash } from "node:crypto";
 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";
 import { retrieve } from "../retriever/retriever.js";
+import { updateConfigValue } from "../core/config.js";
+import { createExcludeMatcher } from "../core/exclude.js";
 import { CODE_SEARCH_FILTER } from "../core/interfaces.js";
 const FILE_MIME_TYPES = {
     ".png": "image/png",
@@ -94,9 +96,16 @@ function sendJson(res, response, origin) {
  * @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).
+ * @param getEmbedder  - Lazily-created embedder for /api/retrieve and reindex passes.
+ * @param token        - Per-run auth token required on every request.
+ * @param configPath   - Path to the opencode-rag.json config file, used by PUT /api/config.
  * @returns An async handler that returns `true` when a route matched or `false` otherwise.
  */
-export function createApiHandler(store, keywordIndex, storePath, cwd, cfg, getEmbedder, token) {
+export function createApiHandler(store, keywordIndex, storePath, cwd, cfg, getEmbedder, token, configPath) {
+    // Mutable config reference so PUT /api/config can update the in-memory
+    // config used by subsequent requests (retrieve, reindex, quirk endpoints).
+    const configRef = { current: cfg };
+    const effectiveConfig = () => configRef.current ?? cfg ?? {};
     return async (req, res) => {
         const url = req.url ?? "/";
         const method = req.method ?? "GET";
@@ -138,7 +147,7 @@ export function createApiHandler(store, keywordIndex, storePath, cwd, cfg, getEm
             embedder: stubEmbedder,
             store,
             keywordIndex,
-            cfg: cfg ?? {},
+            cfg: effectiveConfig(),
             storePath,
         };
         let response;
@@ -150,6 +159,9 @@ export function createApiHandler(store, keywordIndex, storePath, cwd, cfg, getEm
             else if (path === "/api/files") {
                 response = await handleFiles(store);
             }
+            else if (path === "/api/tree" && method === "GET") {
+                response = handleTree(cwd, effectiveConfig());
+            }
             else if (path === "/api/chunks" && !path.includes("/api/chunks/")) {
                 response = await handleChunks(store, params);
             }
@@ -164,16 +176,20 @@ export function createApiHandler(store, keywordIndex, storePath, cwd, cfg, getEm
                 response = await handleCompare(store, params);
             }
             else if (path === "/api/retrieve") {
-                response = await handleRetrieve(store, keywordIndex, getEmbedder, cfg, params);
+                response = await handleRetrieve(store, keywordIndex, getEmbedder, effectiveConfig(), params);
             }
             else if (path === "/api/indexing/status") {
                 response = await handleIndexingStatus(storePath, cwd);
             }
             else if (path === "/api/indexing/reindex" && method === "POST") {
-                response = await handleReindex(cwd, cfg, storePath, store, getEmbedder);
+                response = await handleReindex(cwd, effectiveConfig(), storePath, store, getEmbedder);
+            }
+            else if (path === "/api/config" && method === "GET") {
+                response = await handleConfig(effectiveConfig());
             }
-            else if (path === "/api/config") {
-                response = await handleConfig(cfg);
+            else if (path === "/api/config" && method === "PUT") {
+                const body = await readBody(req);
+                response = handleConfigUpdate(configPath, configRef, body);
             }
             else if (path === "/api/embeddings/projection") {
                 response = await handleEmbeddingProjection(store, params);
@@ -301,6 +317,47 @@ async function handleFiles(store) {
     const files = await store.listFiles();
     return { status: 200, body: files };
 }
+/**
+ * Respond with the workspace **directory** tree (dirs only), used by the UI's
+ * indexing-scope folder selector. `indexing.excludeDirs` are pruned so the
+ * tree stays clean (node_modules, build output, ...); `includeDirs` are NOT
+ * applied — users must be able to see and select every selectable folder.
+ */
+function handleTree(cwd, cfg) {
+    if (!cwd) {
+        return { status: 400, body: { error: "Workspace path not configured" } };
+    }
+    const excludeMatcher = createExcludeMatcher(cfg.indexing.excludeDirs);
+    const MAX_DIRS = 10_000;
+    let visited = 0;
+    function walk(dir, rel) {
+        const children = [];
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return children;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const childRel = rel ? `${rel}/${entry.name}` : entry.name;
+            if (excludeMatcher.excluded(childRel))
+                continue;
+            if (++visited > MAX_DIRS)
+                continue;
+            children.push({
+                name: entry.name,
+                path: childRel,
+                children: walk(join(dir, entry.name), childRel),
+            });
+        }
+        children.sort((a, b) => a.name.localeCompare(b.name));
+        return children;
+    }
+    return { status: 200, body: { tree: walk(cwd, "") } };
+}
 // ── Quirk Memory API ─────────────────────────────────────────────────
 /** Respond with all stored quirks, sorted by last-observed time (most recent first). */
 async function handleQuirks(deps) {
@@ -603,6 +660,68 @@ function redactKeys(obj) {
         }
     }
 }
+/**
+ * Config keys under `indexing` that the UI may write. Values must be arrays
+ * of strings. Add keys here when the UI learns to edit more settings.
+ */
+const INDEXING_STRING_ARRAY_KEYS = new Set([
+    "includeExtensions",
+    "excludeDirs",
+    "excludeFiles",
+    "includeDirs",
+]);
+/**
+ * Apply a validated config patch (`{ indexing: { includeDirs: [...] } }`)
+ * to the on-disk config file and refresh the in-memory config used by
+ * subsequent API requests. Only known sections/keys with validated types
+ * are accepted; anything else is rejected with a 400.
+ */
+function handleConfigUpdate(configPath, configRef, body) {
+    if (!configPath) {
+        return {
+            status: 400,
+            body: { error: "Config file path unavailable — the UI server was started without a config file" },
+        };
+    }
+    const patch = body;
+    if (!patch || typeof patch !== "object" || Array.isArray(patch)) {
+        return { status: 400, body: { error: "Invalid config patch" } };
+    }
+    const otherSections = Object.keys(patch).filter((k) => k !== "indexing");
+    if (otherSections.length > 0) {
+        return { status: 400, body: { error: `Unsupported config section(s): ${otherSections.join(", ")}` } };
+    }
+    const indexingPatch = patch.indexing;
+    if (indexingPatch !== undefined) {
+        if (typeof indexingPatch !== "object" || indexingPatch === null || Array.isArray(indexingPatch)) {
+            return { status: 400, body: { error: "Invalid 'indexing' section" } };
+        }
+        for (const [key, value] of Object.entries(indexingPatch)) {
+            if (!INDEXING_STRING_ARRAY_KEYS.has(key)) {
+                return { status: 400, body: { error: `Unsupported indexing key '${key}'` } };
+            }
+            if (!Array.isArray(value) || value.some((v) => typeof v !== "string")) {
+                return { status: 400, body: { error: `'indexing.${key}' must be an array of strings` } };
+            }
+        }
+    }
+    if (indexingPatch) {
+        for (const [key, value] of Object.entries(indexingPatch)) {
+            const ok = updateConfigValue(configPath, ["indexing", key], value);
+            if (!ok) {
+                return { status: 500, body: { error: `Failed to write 'indexing.${key}' to ${configPath}` } };
+            }
+        }
+        const current = configRef.current ?? {};
+        configRef.current = {
+            ...current,
+            indexing: { ...current.indexing, ...indexingPatch },
+        };
+    }
+    const redacted = JSON.parse(JSON.stringify(configRef.current));
+    redactKeys(redacted);
+    return { status: 200, body: { config: redacted } };
+}
 /**
  * Project chunk embeddings to 2D/3D via PCA for the Embedding Space Explorer.
  * Capped at 5000 chunks and memoized per (maxChunks, dims) so the

package/dist/web/server.d.ts

@@ -18,6 +18,7 @@ export interface WebUiServer {
  * @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).
+ * @param configPath      - Path to the opencode-rag.json config file (used by PUT /api/config).
  * @returns A {@link WebUiServer} handle for the running server.
  */
-export declare function startWebUi(storePath: string, port: number, cwd?: string, vectorDimension?: number, cfg?: import("../core/config.js").RagConfig): Promise<WebUiServer>;
+export declare function startWebUi(storePath: string, port: number, cwd?: string, vectorDimension?: number, cfg?: import("../core/config.js").RagConfig, configPath?: string): Promise<WebUiServer>;

package/dist/web/server.js

@@ -66,9 +66,10 @@ function serveUiAsset(res, filePath) {
  * @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).
+ * @param configPath      - Path to the opencode-rag.json config file (used by PUT /api/config).
  * @returns A {@link WebUiServer} handle for the running server.
  */
-export async function startWebUi(storePath, port, cwd, vectorDimension = 384, cfg) {
+export async function startWebUi(storePath, port, cwd, vectorDimension = 384, cfg, configPath) {
     const store = new LanceDbStore(storePath, vectorDimension);
     const keywordIndex = await KeywordIndex.load(storePath);
     // Lazy embedder for /api/retrieve — initialized on first use
@@ -82,7 +83,7 @@ export async function startWebUi(storePath, port, cwd, vectorDimension = 384, cf
     }
     const html = getStaticHtml();
     const token = randomBytes(24).toString("hex");
-    const apiHandler = createApiHandler(store, keywordIndex, storePath, cwd, cfg, getEmbedder, token);
+    const apiHandler = createApiHandler(store, keywordIndex, storePath, cwd, cfg, getEmbedder, token, configPath);
     const server = createServer(async (req, res) => {
         try {
             // Strip the query string before routing — the auth token arrives as

package/dist/web/ui/assets/{ScatterPlot3D-CzbmvDSQ.js → ScatterPlot3D-DQLl3sKN.js}

@@ -1,4 +1,4 @@
-import{A as vi,h as Mi,u as Vl}from"./index-DOSfQsyL.js";import"./vendor-Dy7HKFCY.js";/**
+import{A as vi,h as Mi,u as Vl}from"./index-BZh9MitV.js";import"./vendor-Dy7HKFCY.js";/**
  * @license
  * Copyright 2010-2026 Three.js Authors
  * SPDX-License-Identifier: MIT