@lapis-notes/search 0.1.3 → 0.1.4

package/dist/search-plugin.js

@@ -9,17 +9,25 @@ import { createNotesSearchTool } from "./notes-search-tool";
 import SearchToolResult from "./search-tool-result.svelte";
 import { reconcileSearchAfterMetadata } from "./search-startup";
 import manifestSpec from "@lapis-notes/search/manifest.json";
+import { observeRecoveredSearchSettings } from "./search-settings-observer";
 export class SearchPlugin extends Plugin {
     settings;
     startupRefreshStarted = false;
     startupRefreshPromise = null;
     providerReconcileReason = null;
     providerReconcilePromise = null;
-    searchManager;
+    managerStopped = false;
+    currentSearchManager;
     constructor(app, pluginManifest = manifestSpec) {
         super(app, pluginManifest);
         this.settings = mergeSearchSettings(null);
-        this.searchManager = new SearchManager(app, () => this.settings);
+        this.currentSearchManager = new SearchManager(app, () => this.settings);
+    }
+    showNotice(message) {
+        new Notice(message, undefined, this.app);
+    }
+    get searchManager() {
+        return this.currentSearchManager;
     }
     getSettings() {
         return {
@@ -33,13 +41,23 @@ export class SearchPlugin extends Plugin {
         };
     }
     async updateSettings(patch) {
-        const previousProvider = resolveSearchEmbeddingProviderConfig(this.settings);
+        const previous = this.settings;
         this.settings = patchSearchSettings(this.settings, patch);
         await this.saveData(this.settings);
+        await this.reconfigureSettings(previous);
+    }
+    async reconfigureSettings(previous) {
+        const manager = this.searchManager;
+        const previousProvider = resolveSearchEmbeddingProviderConfig(previous);
         const nextProvider = resolveSearchEmbeddingProviderConfig(this.settings);
         if (JSON.stringify(previousProvider) !== JSON.stringify(nextProvider)) {
             await this.app.appDatabase.configureSearchEmbeddingProvider(nextProvider);
         }
+        if (this.app.session?.backgroundIndexing &&
+            JSON.stringify(previous.chunking) !==
+                JSON.stringify(this.settings.chunking)) {
+            await manager.configureIndexing();
+        }
     }
     getSearchStatus() {
         return this.searchManager.getStatus();
@@ -48,11 +66,35 @@ export class SearchPlugin extends Plugin {
         return this.searchManager.refreshFromVault("manual-semantic-rebuild");
     }
     async onload() {
+        if (this.managerStopped) {
+            this.currentSearchManager = new SearchManager(this.app, () => this.settings);
+            this.managerStopped = false;
+            this.startupRefreshStarted = false;
+            this.startupRefreshPromise = null;
+            this.providerReconcileReason = null;
+            this.providerReconcilePromise = null;
+        }
         this.settings = mergeSearchSettings(await this.loadData());
         await this.app.appDatabase.configureSearchEmbeddingProvider(resolveSearchEmbeddingProviderConfig(this.settings));
+        this.register(observeRecoveredSearchSettings(this.app, this.manifest.id, (settings) => {
+            if (this.managerStopped)
+                return;
+            const previous = this.settings;
+            this.settings = settings;
+            void this.reconfigureSettings(previous).catch((error) => {
+                if (this.nativeObserverDetached())
+                    return;
+                this.showNotice(`Search settings recovery failed: ${error instanceof Error ? error.message : String(error)}`);
+            });
+        }));
         this.registerEvent(this.app.searchDocumentProviders.on("changed", ({ reason }) => {
             if (this.state !== "enabled")
                 return;
+            if (this.app.session?.backgroundIndexing &&
+                this.app.metadataCache.initialized) {
+                this.scheduleProviderReconciliation(`provider-${reason}`);
+                return;
+            }
             if (!this.app.metadataCache.initialized ||
                 !this.startupRefreshStarted) {
                 return;
@@ -74,7 +116,7 @@ export class SearchPlugin extends Plugin {
             command: {
                 id: "open-search",
                 name: "Open Search",
-                callback: (query) => void this.openSearchInLeftSidebar(query),
+                callback: (query, scope) => this.openSearchInLeftSidebar(query, scope),
             },
         });
         this.registerEvent(this.app.metadataCache.on("loaded", () => {
@@ -88,7 +130,7 @@ export class SearchPlugin extends Plugin {
             name: "Rebuild semantic search embeddings",
             callback: async () => {
                 const status = await this.rebuildSemanticSearch();
-                new Notice(`Semantic search refreshed (${status.readyChunkCount}/${status.chunkCount} ready)`);
+                this.showNotice(`Semantic search refreshed (${status.readyChunkCount}/${status.chunkCount} ready)`);
             },
         });
         this.addCommand({
@@ -104,9 +146,10 @@ export class SearchPlugin extends Plugin {
             id: "rebuild-search-index",
             name: "Rebuild search index",
             callback: async () => {
-                await this.app.appDatabase.rebuildSearchIndex();
+                if (!this.app.session?.backgroundIndexing)
+                    await this.app.appDatabase.rebuildSearchIndex();
                 await this.refreshIndex("rebuild");
-                new Notice("Search index rebuilt");
+                this.showNotice("Search index rebuilt");
             },
         });
         this.addCommand({
@@ -118,7 +161,15 @@ export class SearchPlugin extends Plugin {
     refreshIndex(reason = "manual") {
         return this.searchManager.refreshFromVault(reason);
     }
+    async disable() {
+        if (this.app.session?.backgroundIndexing) {
+            this.managerStopped = true;
+            await this.searchManager.dispose();
+        }
+        await super.disable();
+    }
     async onunload() {
+        this.managerStopped = true;
         await this.searchManager.dispose();
     }
     startupRefresh() {
@@ -126,44 +177,68 @@ export class SearchPlugin extends Plugin {
             return this.startupRefreshPromise;
         if (this.startupRefreshStarted)
             return Promise.resolve();
+        const manager = this.searchManager;
         this.startupRefreshStarted = true;
-        this.startupRefreshPromise = reconcileSearchAfterMetadata(this.app, this.searchManager)
+        this.startupRefreshPromise = reconcileSearchAfterMetadata(this.app, manager)
             .then(() => undefined)
             .catch((error) => {
+            if (this.searchManager !== manager)
+                return;
             this.startupRefreshStarted = false;
-            new Notice(`Search index refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+            if (this.nativeObserverDetached())
+                return;
+            this.showNotice(`Search index refresh failed: ${error instanceof Error ? error.message : String(error)}`);
         })
             .finally(() => {
-            if (!this.startupRefreshStarted)
+            if (this.searchManager === manager && !this.startupRefreshStarted)
                 this.startupRefreshPromise = null;
         });
         return this.startupRefreshPromise;
     }
     scheduleProviderReconciliation(reason) {
+        if (this.managerStopped || this.state !== "enabled")
+            return;
         this.providerReconcileReason = reason;
         if (this.providerReconcilePromise)
             return;
+        const manager = this.searchManager;
         this.providerReconcilePromise = (async () => {
             await this.startupRefresh();
-            while (this.providerReconcileReason) {
+            while (this.providerReconcileReason &&
+                !this.managerStopped &&
+                this.searchManager === manager &&
+                this.state === "enabled") {
                 this.providerReconcileReason = null;
-                await this.searchManager.reconcileStartup();
+                await manager.reconcileStartup();
             }
         })()
             .catch((error) => {
-            new Notice(`Search provider refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+            if (this.searchManager !== manager)
+                return;
+            if (this.nativeObserverDetached())
+                return;
+            this.showNotice(`Search provider refresh failed: ${error instanceof Error ? error.message : String(error)}`);
         })
             .finally(() => {
+            if (this.searchManager !== manager)
+                return;
             this.providerReconcilePromise = null;
+            if (this.managerStopped || this.state !== "enabled") {
+                this.providerReconcileReason = null;
+                return;
+            }
             if (this.providerReconcileReason) {
                 this.scheduleProviderReconciliation(this.providerReconcileReason);
             }
         });
     }
-    async openSearchInLeftSidebar(query = "") {
+    async openSearchInLeftSidebar(query = "", scope = "files") {
         const existing = this.app.workspace.getLeavesOfType(SearchViewType)[0];
         const target = existing ?? this.app.workspace.ensureSideLeaf(SearchViewType, "left");
-        await target.setViewState({ type: SearchViewType, state: { query } });
+        await target.setViewState({
+            type: SearchViewType,
+            state: { query, scope },
+        });
         this.app.workspace.activateLeaf(target, {
             focusRootHost: false,
             source: "api",
@@ -171,4 +246,11 @@ export class SearchPlugin extends Plugin {
         });
         await this.app.workspace.revealLeaf(target);
     }
+    nativeObserverDetached() {
+        return Boolean(this.app.session?.backgroundIndexing &&
+            (this.app.backgroundIndexing?.detached ||
+                this.managerStopped ||
+                this.state === "disabling" ||
+                this.state === "disabled"));
+    }
 }

package/dist/search-provider-controller.d.ts

@@ -0,0 +1,25 @@
+import { type SearchQueryExpression, type SearchProviderHit, type SearchProviderStatus, type SearchResultProvider, type SearchResultProviderRegistry, type SearchResultRequest } from "@lapis-notes/api";
+export type ProviderResults = {
+    provider: SearchResultProvider;
+    hits: SearchProviderHit[];
+    busy: boolean;
+    next?: string;
+    generation?: string;
+    status?: SearchProviderStatus;
+    unavailable?: string;
+};
+type Input = Omit<SearchResultRequest, "query" | "cursor" | "signal">;
+export declare function searchProviderFields(node: SearchQueryExpression | null): string[];
+/** Independent sources publish pages without clearing successful peer results. */
+export declare class SearchProviderController {
+    #private;
+    readonly registry: SearchResultProviderRegistry;
+    readonly report: (error: unknown) => void;
+    constructor(registry: SearchResultProviderRegistry, report: (error: unknown) => void);
+    subscribe(listener: (rows: ProviderResults[]) => void): () => void;
+    search(input: Input, enabled: boolean, retain?: boolean): void;
+    more(id: string): void;
+    refresh(): void;
+    close(): void;
+}
+export {};

package/dist/search-provider-controller.js

@@ -0,0 +1,157 @@
+import { parseSearchQueryAst, } from "@lapis-notes/api";
+export function searchProviderFields(node) {
+    if (!node)
+        return [];
+    switch (node.type) {
+        case "field":
+            return [node.name, ...searchProviderFields(node.value)];
+        case "property":
+            return ["property"];
+        case "group":
+            return searchProviderFields(node.expression);
+        case "not":
+            return searchProviderFields(node.operand);
+        case "and":
+        case "or":
+            return node.clauses.flatMap(searchProviderFields);
+        case "literal":
+            return node.kind === "regex" ? ["regex"] : [];
+        default:
+            return [];
+    }
+}
+/** Independent sources publish pages without clearing successful peer results. */
+export class SearchProviderController {
+    registry;
+    report;
+    #rows = new Map();
+    #listeners = new Set();
+    #abort = new AbortController();
+    #input;
+    #enabled = false;
+    #epoch = 0;
+    #timer;
+    #event;
+    constructor(registry, report) {
+        this.registry = registry;
+        this.report = report;
+        this.#event = registry.on("changed", () => {
+            clearTimeout(this.#timer);
+            this.#timer = setTimeout(() => {
+                if (this.#input)
+                    this.search(this.#input, this.#enabled, true);
+            }, 75);
+        });
+    }
+    subscribe(listener) {
+        this.#listeners.add(listener);
+        listener([...this.#rows.values()]);
+        return () => {
+            this.#listeners.delete(listener);
+        };
+    }
+    #emit() {
+        for (const listener of this.#listeners)
+            listener([...this.#rows.values()]);
+    }
+    search(input, enabled, retain = false) {
+        this.#input = input;
+        this.#enabled = enabled;
+        this.#abort.abort();
+        this.#abort = new AbortController();
+        const epoch = ++this.#epoch;
+        const previous = this.#rows;
+        this.#rows = new Map();
+        if (enabled && input.text.trim()) {
+            const query = parseSearchQueryAst(input.text);
+            if (!query.diagnostics.length)
+                for (const provider of this.registry.getAll()) {
+                    const unsupported = searchProviderFields(query.expression).filter((field) => !provider.fields.includes(field));
+                    const mode = input.mode === "auto" ? "lexical" : input.mode;
+                    const unavailable = unsupported.length
+                        ? `Unsupported filters: ${[...new Set(unsupported)].join(", ")}`
+                        : !provider.modes.includes(mode)
+                            ? `${provider.label} supports text search only`
+                            : undefined;
+                    const row = {
+                        provider,
+                        hits: retain ? previous.get(provider.id)?.hits ?? [] : [],
+                        busy: !unavailable,
+                        unavailable,
+                    };
+                    this.#rows.set(provider.id, row);
+                    if (!unavailable)
+                        void this.#run(row, epoch, Math.max(input.limit, row.hits.length));
+                }
+        }
+        this.#emit();
+    }
+    async #run(row, epoch, limit, append = false) {
+        if (!this.#input)
+            return;
+        const signal = this.#abort.signal;
+        const input = this.#input;
+        let hits = append ? [...row.hits] : [];
+        let cursor = append ? row.next : undefined;
+        const cursors = new Set();
+        row.busy = true;
+        this.#emit();
+        try {
+            // Bounded work even when a source returns pages without matches.
+            for (let n = 0; n < 32; n++) {
+                const page = await row.provider.search({
+                    ...input,
+                    query: parseSearchQueryAst(input.text),
+                    cursor,
+                    signal,
+                });
+                if (signal.aborted || epoch !== this.#epoch)
+                    return;
+                if (cursor && row.generation && row.generation !== page.generation)
+                    hits = [];
+                row.generation = page.generation;
+                const merged = new Map(hits.map((hit) => [hit.id, hit]));
+                for (const hit of page.hits)
+                    merged.set(hit.id, hit);
+                hits = [...merged.values()];
+                Object.assign(row, { hits, status: page.status, next: page.next });
+                this.#emit();
+                cursor = page.next;
+                if (!cursor || hits.length >= limit)
+                    break;
+                if (cursors.has(cursor))
+                    throw new Error("Search provider returned a repeated cursor");
+                cursors.add(cursor);
+            }
+        }
+        catch (error) {
+            if (!signal.aborted && epoch === this.#epoch) {
+                row.unavailable =
+                    "Search is temporarily unavailable. Refresh to retry.";
+                this.report(error);
+            }
+        }
+        finally {
+            if (epoch === this.#epoch) {
+                row.busy = false;
+                this.#emit();
+            }
+        }
+    }
+    more(id) {
+        const row = this.#rows.get(id);
+        if (row && row.next && !row.busy)
+            void this.#run(row, this.#epoch, row.hits.length + (this.#input?.limit ?? 100), true);
+    }
+    refresh() {
+        if (this.#input)
+            this.search(this.#input, this.#enabled, true);
+    }
+    close() {
+        ++this.#epoch;
+        this.#abort.abort();
+        clearTimeout(this.#timer);
+        this.registry.offref(this.#event);
+        this.#listeners.clear();
+    }
+}

package/dist/search-provider-groups.d.ts

@@ -0,0 +1,14 @@
+import type { SearchProviderHit, SearchResultProvider } from "@lapis-notes/api";
+import type { ProviderResults } from "./search-provider-controller";
+export type ProviderVersion = {
+    provider: SearchResultProvider;
+    hit: SearchProviderHit;
+};
+export type ProviderGroup = {
+    id: string;
+    title: string;
+    path?: string;
+    extension?: string;
+    versions: ProviderVersion[];
+};
+export declare function groupProviderResults(rows: ProviderResults[]): ProviderGroup[];

package/dist/search-provider-groups.js

@@ -0,0 +1,60 @@
+export function groupProviderResults(rows) {
+    const groups = new Map();
+    for (const row of rows)
+        for (const hit of row.hits) {
+            const id = hit.path ?? `${row.provider.id}:${hit.groupId}`;
+            let group = groups.get(id);
+            if (!group) {
+                group = {
+                    id,
+                    title: hit.title,
+                    path: hit.path,
+                    extension: hit.extension,
+                    versions: [],
+                };
+                groups.set(id, group);
+            }
+            const content = hit.version?.contentId;
+            const duplicate = content
+                ? group.versions.find((version) => version.provider.id === row.provider.id &&
+                    version.hit.version?.contentId === content)
+                : undefined;
+            const reference = (item) => item.version
+                ? {
+                    id: item.version.id,
+                    label: item.version.label,
+                    author: item.version.author,
+                    timestamp: item.version.timestamp,
+                    target: item.target,
+                }
+                : undefined;
+            if (duplicate && duplicate.hit.version && hit.version) {
+                const refs = new Map((duplicate.hit.version.references ?? [reference(duplicate.hit)]).map((ref) => [ref.id, ref]));
+                refs.set(hit.version.id, reference(hit));
+                const primary = hit.version.timestamp > duplicate.hit.version.timestamp
+                    ? hit
+                    : duplicate.hit;
+                duplicate.hit = {
+                    ...primary,
+                    id: `${hit.groupId}/content/${content}`,
+                    version: {
+                        ...primary.version,
+                        occurrences: refs.size,
+                        references: [...refs.values()].sort((a, b) => b.timestamp - a.timestamp),
+                    },
+                };
+            }
+            else
+                group.versions.push({
+                    provider: row.provider,
+                    hit: content
+                        ? { ...hit, id: `${hit.groupId}/content/${content}` }
+                        : hit,
+                });
+        }
+    return [...groups.values()].map((group) => ({
+        ...group,
+        versions: group.versions.sort((a, b) => (b.hit.timestamp ?? 0) - (a.hit.timestamp ?? 0) ||
+            a.hit.id.localeCompare(b.hit.id)),
+    }));
+}

package/dist/search-settings-observer.d.ts

@@ -0,0 +1,4 @@
+import type { App } from "@lapis-notes/api";
+import { type SearchPluginSettings } from "./search-settings";
+/** Observe owner-applied recovery without writing the recovered document again. */
+export declare function observeRecoveredSearchSettings(app: Pick<App, "configuration">, pluginId: string, apply: (settings: SearchPluginSettings) => void): () => void;

package/dist/search-settings-observer.js

@@ -0,0 +1,10 @@
+import { mergeSearchSettings, } from "./search-settings";
+/** Observe owner-applied recovery without writing the recovered document again. */
+export function observeRecoveredSearchSettings(app, pluginId, apply) {
+    const changed = app.configuration.on("plugin-data-updated", (event) => {
+        if (event.pluginId !== pluginId || event.origin === "plugin-save")
+            return;
+        apply(mergeSearchSettings(event.value));
+    });
+    return () => app.configuration.offref(changed);
+}

package/dist/search-settings-tab.js

@@ -126,10 +126,10 @@ export class SearchSettingsTab extends PluginSettingTab {
         this.display();
         try {
             const status = await this.searchPlugin.rebuildSemanticSearch();
-            new Notice(`Semantic search refreshed (${status.readyChunkCount}/${status.chunkCount} ready)`);
+            new Notice(`Semantic search refreshed (${status.readyChunkCount}/${status.chunkCount} ready)`, undefined, this.app);
         }
         catch (error) {
-            new Notice(`Semantic search refresh failed: ${error instanceof Error ? error.message : String(error)}`);
+            new Notice(`Semantic search refresh failed: ${error instanceof Error ? error.message : String(error)}`, undefined, this.app);
         }
         finally {
             this.rebuilding = false;

package/dist/search-tool-result.css

@@ -6,12 +6,6 @@
   gap: 0.375rem;
 }
 
-[data-ui-component="search-tool-result"] [data-ui-part="empty"] {
-  padding: 0.375rem;
-  color: var(--muted-foreground);
-  font-size: 0.8125rem;
-}
-
 [data-ui-component="search-tool-result"] [data-ui-part="hit"] {
   display: flex;
   min-width: 0;
@@ -37,7 +31,8 @@
 [data-ui-component="search-tool-result"] [data-ui-part="file"]:hover,
 [data-ui-component="search-tool-result"] [data-ui-part="file"]:focus-visible,
 [data-ui-component="search-tool-result"] [data-ui-part="snippet"]:hover,
-[data-ui-component="search-tool-result"] [data-ui-part="snippet"]:focus-visible {
+[data-ui-component="search-tool-result"]
+  [data-ui-part="snippet"]:focus-visible {
   background: var(
     --ui-workspace-explorer-row-hover-background,
     var(--sidebar-accent)

package/dist/search-tool-result.svelte

@@ -1,5 +1,7 @@
 <script lang="ts">
   import type { AgentResultViewProps } from "@lapis-notes/api";
+  import * as Empty from "@lapismd/design-core/shadcn/empty";
+  import SearchIcon from "@lucide/svelte/icons/search";
   import type { App } from "@lapis-notes/api";
   import {
     fileNameFromPath,
@@ -27,14 +29,19 @@
 
 <div data-ui-component="search-tool-result">
   {#if hits.length === 0}
-    <p data-ui-part="empty">No matching notes.</p>
+    <Empty.Root data-ui-part="empty">
+      <Empty.Header>
+        <Empty.Media variant="icon"><SearchIcon aria-hidden="true" /></Empty.Media>
+        <Empty.Description>No matching notes.</Empty.Description>
+      </Empty.Header>
+    </Empty.Root>
   {:else}
     {#each hits as hit (hit.path)}
       <div data-ui-part="hit">
         <button
           type="button"
           data-ui-part="file"
-          aria-label={`Open ${fileNameFromPath(hit.path)}`}
+          aria-label={`Open ${fileNameFromPath(hit.path)} ${hit.path}`}
           onclick={() => void openHit(hit)}
         >
           <span data-ui-part="file-label">{fileNameFromPath(hit.path)}</span>

package/dist/search-view.d.ts

@@ -2,13 +2,17 @@ import { View, type WorkspaceLeaf } from "@lapis-notes/api";
 export { SearchViewType } from "./search-view-type";
 export declare class SearchView extends View {
     private component;
+    private snapshot?;
+    private closing?;
     constructor(leaf: WorkspaceLeaf);
     getViewType(): string;
     getDisplayText(): string;
     getIcon(): string;
+    getState(): Record<string, unknown>;
     protected onOpen(): Promise<void>;
     protected onClose(): Promise<void>;
     onload(): void;
     setState(state: Record<string, unknown>): Promise<void>;
-    onunload(): void;
+    onunload(): Promise<void>;
+    private stopPanel;
 }

package/dist/search-view.js

@@ -1,10 +1,12 @@
-import { View } from "@lapis-notes/api";
+import { View, } from "@lapis-notes/api";
 import { mount, unmount } from "svelte";
 import SearchPanel from "./search-panel.svelte";
 import { SearchViewType } from "./search-view-type";
 export { SearchViewType } from "./search-view-type";
 export class SearchView extends View {
     component = null;
+    snapshot;
+    closing;
     constructor(leaf) {
         super(leaf);
     }
@@ -17,32 +19,58 @@ export class SearchView extends View {
     getIcon() {
         return "search";
     }
+    getState() {
+        return {
+            ...super.getState(),
+            ...(this.component?.getSearchState?.() ?? this.snapshot),
+        };
+    }
     onOpen() {
         return Promise.resolve();
     }
     onClose() {
-        return Promise.resolve();
+        return this.stopPanel();
     }
     onload() {
+        this.closing = undefined;
         this.component = mount(SearchPanel, {
             target: this.containerEl,
             props: {
                 app: this.app,
+                initialScope: (["files", "history", "all"].includes(String(this.getState()["scope"]))
+                    ? this.getState()["scope"]
+                    : "files"),
                 initialQuery: typeof this.getState()["query"] === "string"
                     ? this.getState()["query"]
                     : "",
+                onStateChange: () => {
+                    if (this.component)
+                        this.app.workspace.requestSaveLayout({
+                            source: "api",
+                            operation: "search-state",
+                        });
+                },
             },
         });
     }
     async setState(state) {
+        this.snapshot = undefined;
         await super.setState(state);
+        if (["files", "history", "all"].includes(String(state["scope"])))
+            this.component?.setSearchScope?.(state["scope"]);
         if (typeof state["query"] === "string") {
             this.component?.setSearchQuery?.(state["query"]);
         }
     }
     onunload() {
-        if (this.component)
-            void unmount(this.component);
+        return this.stopPanel();
+    }
+    stopPanel() {
+        if (this.closing)
+            return this.closing;
+        this.snapshot = this.component?.getSearchState?.() ?? this.snapshot;
+        const current = this.component;
         this.component = null;
+        return (this.closing = current ? unmount(current) : Promise.resolve());
     }
 }