@lapis-notes/search 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Search changelog
+
+## 0.1.0
+
+- Initial independent public package extracted from Lapis Notes without changing
+  the runtime plugin ID.

package/LICENSE.md

@@ -0,0 +1,8 @@
+# License
+
+Copyright (c) LapisMD contributors.
+
+This software is licensed under the GNU Affero General Public License, version
+3 or (at your option) any later version (`AGPL-3.0-or-later`). The complete
+license text is available from the
+[GNU Project](https://www.gnu.org/licenses/agpl-3.0.html).

package/README.md

@@ -0,0 +1,20 @@
+# Search
+
+Search files, metadata, tags, and note content.
+
+## Install for static composition
+
+```sh
+pnpm add @lapis-notes/search
+```
+
+Register the exported plugin class in the application's `PluginProfile`. Import
+`@lapis-notes/search/styles.css?inline` and pass the CSS through the static
+registration so the host owns its lifecycle.
+
+The runtime plugin ID is `search`. A matching signed
+`search-0.1.0.lapis-plugin` archive is attached to the
+package-scoped GitHub release for manual or registry installation.
+
+See the [repository README](https://github.com/lapismd/lapis-plugins#readme) for
+development, validation, and release-gate details.

package/dist/agent-tools.d.ts

@@ -0,0 +1 @@
+export { createNotesSearchTool } from "./notes-search-tool";

package/dist/agent-tools.js

@@ -0,0 +1 @@
+export { createNotesSearchTool } from "./notes-search-tool";

package/dist/built-in-search-document-providers.d.ts

@@ -0,0 +1,5 @@
+import type { SearchDocumentProvider } from "@lapis-notes/api";
+type LocalSearchDocumentProvider = Omit<SearchDocumentProvider, "id">;
+export declare const MARKDOWN_SEARCH_DOCUMENT_PROVIDER: LocalSearchDocumentProvider;
+export declare const CANVAS_SEARCH_DOCUMENT_PROVIDER: LocalSearchDocumentProvider;
+export {};

package/dist/built-in-search-document-providers.js

@@ -0,0 +1,30 @@
+function canvasText(content) {
+    try {
+        const canvas = JSON.parse(content);
+        return [
+            ...(canvas.nodes ?? []).flatMap((node) => [
+                node.type,
+                node.text,
+                node.label,
+                node.file,
+                node.url,
+            ]),
+            ...(canvas.edges ?? []).map((edge) => edge.label),
+        ]
+            .filter((part) => Boolean(part?.trim()))
+            .join("\n");
+    }
+    catch {
+        return content;
+    }
+}
+export const MARKDOWN_SEARCH_DOCUMENT_PROVIDER = {
+    version: "1",
+    matches: (file) => ["md", "markdown"].includes(file.extension.toLowerCase()),
+    extract: ({ content }) => ({ content }),
+};
+export const CANVAS_SEARCH_DOCUMENT_PROVIDER = {
+    version: "1",
+    matches: (file) => file.extension.toLowerCase() === "canvas",
+    extract: ({ content }) => ({ content: canvasText(content) }),
+};

package/dist/highlighted-text.svelte

@@ -0,0 +1,41 @@
+<script lang="ts">
+  type Range = { start: number; end: number };
+
+  let {
+    text,
+    ranges = [],
+  }: {
+    text: string;
+    ranges?: Range[];
+  } = $props();
+
+  const segments = $derived.by(() => {
+    const normalized = ranges
+      .map((range) => ({
+        start: Math.max(0, Math.min(text.length, range.start)),
+        end: Math.max(0, Math.min(text.length, range.end)),
+      }))
+      .filter((range) => range.end > range.start)
+      .sort((left, right) => left.start - right.start);
+    const output: Array<{ text: string; highlighted: boolean }> = [];
+    let offset = 0;
+    for (const range of normalized) {
+      const start = Math.max(offset, range.start);
+      if (start > offset) {
+        output.push({ text: text.slice(offset, start), highlighted: false });
+      }
+      if (range.end > start) {
+        output.push({ text: text.slice(start, range.end), highlighted: true });
+      }
+      offset = Math.max(offset, range.end);
+    }
+    if (offset < text.length) {
+      output.push({ text: text.slice(offset), highlighted: false });
+    }
+    return output;
+  });
+</script>
+
+{#each segments as segment, index (`${index}:${segment.text}`)}
+  {#if segment.highlighted}<mark>{segment.text}</mark>{:else}{segment.text}{/if}
+{/each}

package/dist/highlighted-text.svelte.d.ts

@@ -0,0 +1,11 @@
+type Range = {
+    start: number;
+    end: number;
+};
+type $$ComponentProps = {
+    text: string;
+    ranges?: Range[];
+};
+declare const HighlightedText: import("svelte").Component<$$ComponentProps, {}, "">;
+type HighlightedText = ReturnType<typeof HighlightedText>;
+export default HighlightedText;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import "./styles.css";
+export { default as manifest } from "../../manifest.json";
+export { SearchManager } from "./search-manager";
+export type { SearchQueryHit, SearchQueryParams, SearchQueryResult, } from "./search-manager";
+export { SearchPanel, SearchToolResult } from "./public-components";
+export { SearchPlugin } from "./search-plugin";
+export { createNotesSearchSlashCommand } from "./notes-search-command";
+export { createNotesSearchTool } from "./notes-search-tool";
+export { DEFAULT_SEARCH_SETTINGS, SEARCH_VIEW_SORT_OPTIONS, SEARCH_EMBEDDING_MODEL_OPTIONS, mergeSearchSettings, patchSearchSettings, resolveSearchEmbeddingProviderConfig, } from "./search-settings";
+export type { SearchPluginSettings, SearchPluginSettingsPatch, SearchResultFacet, SearchRetrievalMode, SearchViewSortMode, } from "./search-settings";
+export { SearchView, SearchViewType } from "./search-view";

package/dist/index.js

@@ -0,0 +1,9 @@
+import "./styles.css";
+export { default as manifest } from "../../manifest.json";
+export { SearchManager } from "./search-manager";
+export { SearchPanel, SearchToolResult } from "./public-components";
+export { SearchPlugin } from "./search-plugin";
+export { createNotesSearchSlashCommand } from "./notes-search-command";
+export { createNotesSearchTool } from "./notes-search-tool";
+export { DEFAULT_SEARCH_SETTINGS, SEARCH_VIEW_SORT_OPTIONS, SEARCH_EMBEDDING_MODEL_OPTIONS, mergeSearchSettings, patchSearchSettings, resolveSearchEmbeddingProviderConfig, } from "./search-settings";
+export { SearchView, SearchViewType } from "./search-view";

package/dist/notes-search-command.d.ts

@@ -0,0 +1,2 @@
+import type { AppSlashCommandDefinition } from "@lapis-notes/api/agent-skills";
+export declare function createNotesSearchSlashCommand(): AppSlashCommandDefinition;

package/dist/notes-search-command.js

@@ -0,0 +1,8 @@
+export function createNotesSearchSlashCommand() {
+    return {
+        name: "search",
+        description: "Search notes in the current conversation scope.",
+        argumentHint: "<query>",
+        dispatch: { kind: "tool", tool: "notes_search" },
+    };
+}

package/dist/notes-search-tool.d.ts

@@ -0,0 +1,8 @@
+import type { AppTool } from "@lapis-notes/api";
+import type { SearchManager } from "./search-manager";
+interface NotesSearchInput {
+    query: string;
+    limit?: number;
+}
+export declare function createNotesSearchTool(searchManager: Pick<SearchManager, "query">): AppTool<NotesSearchInput>;
+export {};

package/dist/notes-search-tool.js

@@ -0,0 +1,84 @@
+const MARKDOWN_SOURCE_PROVIDER_ID = "search:markdown";
+const HIDDEN_NOTE_SEGMENTS = new Set([".obsidian", ".lapis", ".trash"]);
+const MAX_STRUCTURED_RESULT_BYTES = 48 * 1024;
+export function createNotesSearchTool(searchManager) {
+    return {
+        name: "notes_search",
+        description: `
+Search the user's Lapis Notes using the application's indexed note search.
+
+Use this tool whenever the user asks to:
+- find, search, locate, recall, or look up notes
+- find information previously written in their notes
+- discover notes related to a topic
+- search across the current folder/project
+
+Prefer this tool over shell commands such as grep, rg, find, or manually
+walking the notes filesystem. This tool uses the application's index and
+respects the current conversation's note scope.
+
+Returns lightweight matches. Use read to inspect a selected result.
+`.trim(),
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", minLength: 1, maxLength: 1_000 },
+                limit: { type: "integer", minimum: 1, maximum: 50, default: 10 },
+            },
+            required: ["query"],
+            additionalProperties: false,
+        },
+        outputSchema: {
+            type: "object",
+            properties: {
+                results: { type: "array" },
+            },
+            required: ["results"],
+            additionalProperties: false,
+        },
+        effect: "read",
+        execute: async (input, context) => executeNotesSearch(searchManager, input, context),
+    };
+}
+async function executeNotesSearch(searchManager, input, context) {
+    context.signal.throwIfAborted();
+    const limit = input.limit ?? 10;
+    const result = await searchManager.query({
+        term: input.query,
+        limit,
+        pathPrefix: context.scope.directory,
+        sourceProviderIds: [MARKDOWN_SOURCE_PROVIDER_ID],
+    });
+    context.signal.throwIfAborted();
+    const results = [];
+    for (const hit of result.hits) {
+        if (!isAllowedMarkdownPath(hit.document.path))
+            continue;
+        const entry = {
+            path: hit.document.path,
+            score: Number.isFinite(hit.score) ? hit.score : 0,
+            snippets: hit.snippets.slice(0, 3).map((snippet) => ({
+                text: snippet.text.slice(0, 500),
+                offset: Math.max(0, snippet.offset),
+            })),
+        };
+        if (new TextEncoder().encode(JSON.stringify({ results: [...results, entry] }))
+            .byteLength > MAX_STRUCTURED_RESULT_BYTES) {
+            break;
+        }
+        results.push(entry);
+        if (results.length >= limit)
+            break;
+    }
+    const structuredContent = { results };
+    return {
+        content: [{ type: "text", text: JSON.stringify(structuredContent) }],
+        structuredContent,
+    };
+}
+function isAllowedMarkdownPath(path) {
+    const segments = path.split("/");
+    const extension = segments.at(-1)?.split(".").at(-1)?.toLowerCase();
+    return ((extension === "md" || extension === "markdown") &&
+        !segments.some((segment) => HIDDEN_NOTE_SEGMENTS.has(segment)));
+}

package/dist/public-components.d.ts

@@ -0,0 +1,2 @@
+export { default as SearchPanel } from "./search-panel.svelte";
+export { default as SearchToolResult } from "./search-tool-result.svelte";

package/dist/public-components.js

@@ -0,0 +1,2 @@
+export { default as SearchPanel } from "./search-panel.svelte";
+export { default as SearchToolResult } from "./search-tool-result.svelte";

package/dist/search-manager.d.ts

@@ -0,0 +1,92 @@
+import { type App, type AppDatabaseSearchDiagnostics, type AppDatabaseSearchScoreBreakdown, type AppDatabaseSearchSnippet, type SearchEmbeddingProviderConfig, type SearchEmbeddingRuntimeStatus, type CachedMetadata, type SearchDocumentRecord, type TFile } from "@lapis-notes/api";
+import { type SearchPluginSettings } from "./search-settings";
+export interface SearchQueryParams {
+    term: string;
+    limit?: number;
+    pathPrefix?: string;
+    snippetLength?: number;
+    caseSensitive?: boolean;
+    mode?: "auto" | "lexical" | "vector" | "hybrid";
+    sourceProviderIds?: string[];
+}
+export interface SearchQueryHit {
+    id: string;
+    score: number;
+    document: SearchDocumentRecord;
+    snippets: AppDatabaseSearchSnippet[];
+    retrievalMode: "lexical" | "vector" | "hybrid";
+    scoreBreakdown: AppDatabaseSearchScoreBreakdown;
+    matchedChunkIds: string[];
+    diagnostics?: AppDatabaseSearchDiagnostics;
+}
+export interface SearchRuntimeStatus {
+    backendKind: string;
+    provider: SearchEmbeddingProviderConfig | null;
+    runtime: SearchEmbeddingRuntimeStatus | null;
+    documentCount: number;
+    chunkCount: number;
+    readyChunkCount: number;
+    pendingChunkCount: number;
+    errorChunkCount: number;
+    lastError: string | null;
+    isRefreshing: boolean;
+    refreshReason: string | null;
+    refreshProgress: {
+        processed: number;
+        total: number;
+    };
+    refreshedAt: number | null;
+}
+export interface SearchQueryResult {
+    count: number;
+    hits: SearchQueryHit[];
+}
+export declare class SearchManager {
+    readonly app: App;
+    private readonly getSettings;
+    private refreshPromise;
+    private queuedRefreshReason;
+    private refreshState;
+    private readonly queuedChanges;
+    private readonly queuedDeletes;
+    private readonly flushQueuedChanges;
+    private readonly ownedSourceProviderIds;
+    private changeTrackingReady;
+    private sourceGeneration;
+    private reconcileCheckpointReady;
+    private reconcileCheckpointDirty;
+    private reconcileCheckpointGeneration;
+    private activeIncrementalOperations;
+    private reconcileCheckpointWrite;
+    private queuedProcessing;
+    private readonly pendingIncrementalOperations;
+    private disposed;
+    constructor(app: App, getSettings?: () => SearchPluginSettings);
+    processChange(file: TFile, content: string, cache: CachedMetadata): Promise<void>;
+    processDelete(file: TFile | string): Promise<void>;
+    query(params: SearchQueryParams): Promise<SearchQueryResult>;
+    getStatus(): Promise<SearchRuntimeStatus>;
+    refreshFromVault(reason?: string): Promise<SearchRuntimeStatus>;
+    reconcileStartup(): Promise<SearchRuntimeStatus>;
+    private runRefreshQueue;
+    trackChanges(): () => void;
+    dispose(): Promise<void>;
+    private processFile;
+    private projectionSignature;
+    private currentReconcileFingerprint;
+    private readReconcileCheckpoint;
+    private markReconcileCheckpointDirty;
+    private recordSourceMutation;
+    private invalidateReconcileCheckpoint;
+    private persistReconcileCheckpoint;
+    private trackIncrementalOperation;
+    private searchManifestRows;
+    private metadataManifestRows;
+    private usesMetadataPipeline;
+    private fileAtPath;
+    private processFileSafely;
+    private handleProviderFailure;
+    private processQueuedChanges;
+    private drainQueuedChanges;
+    private runRefresh;
+}