@lapis-notes/search 0.1.0

package/dist/search-tool-result.css

@@ -0,0 +1,70 @@
+[data-ui-component="search-tool-result"] {
+  display: flex;
+  width: 100%;
+  min-width: 0;
+  flex-direction: column;
+  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;
+  flex-direction: column;
+  gap: 0.25rem;
+}
+
+[data-ui-component="search-tool-result"] [data-ui-part="file"],
+[data-ui-component="search-tool-result"] [data-ui-part="snippet"] {
+  box-sizing: border-box;
+  width: 100%;
+  min-width: 0;
+  border: 0;
+  border-radius: var(--ui-workspace-radius-small, 0.25rem);
+  padding: 0.375rem 0.5rem;
+  color: inherit;
+  background: transparent;
+  font: inherit;
+  text-align: start;
+  cursor: pointer;
+}
+
+[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 {
+  background: var(
+    --ui-workspace-explorer-row-hover-background,
+    var(--sidebar-accent)
+  );
+  outline: 2px solid transparent;
+}
+
+[data-ui-component="search-tool-result"] [data-ui-part="file-label"] {
+  overflow: hidden;
+  font-weight: 600;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+[data-ui-component="search-tool-result"] [data-ui-part="file-path"] {
+  overflow: hidden;
+  color: var(--muted-foreground);
+  font-size: 0.75rem;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+[data-ui-component="search-tool-result"] [data-ui-part="snippet-text"] {
+  display: -webkit-box;
+  overflow: hidden;
+  -webkit-box-orient: vertical;
+  -webkit-line-clamp: 3;
+  font-size: 0.8125rem;
+  line-height: 1.35;
+}

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

@@ -0,0 +1,16 @@
+import { type App, type EditorPosition } from "@lapis-notes/api";
+import type { AgentResultViewProps } from "@lapis-notes/api";
+export type NotesSearchSnippet = {
+    text: string;
+    offset: number;
+};
+export type NotesSearchHit = {
+    path: string;
+    score: number;
+    snippets: NotesSearchSnippet[];
+};
+export declare function notesSearchHitsFromOutput(output: unknown): NotesSearchHit[];
+export declare function fileNameFromPath(path: string): string;
+export declare function editorPositionFromOffset(source: string, offset: number): EditorPosition;
+export declare function openNotesSearchHit(app: App, hit: NotesSearchHit, snippet?: NotesSearchSnippet): Promise<void>;
+export declare function searchToolResultProps(props: AgentResultViewProps<App>): NotesSearchHit[];

package/dist/search-tool-result.js

@@ -0,0 +1,111 @@
+import { FileView, TextFileView, TFile, } from "@lapis-notes/api";
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function parseJson(value) {
+    if (typeof value !== "string")
+        return value;
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function normalizeHits(value) {
+    if (!Array.isArray(value))
+        return [];
+    const hits = [];
+    for (const entry of value) {
+        const record = asRecord(entry);
+        if (!record)
+            continue;
+        const path = record.path;
+        if (typeof path !== "string" || !path.trim())
+            continue;
+        const snippets = Array.isArray(record.snippets)
+            ? record.snippets.flatMap((snippet) => {
+                const item = asRecord(snippet);
+                if (!item || typeof item.text !== "string")
+                    return [];
+                return [
+                    {
+                        text: item.text,
+                        offset: typeof item.offset === "number" && Number.isFinite(item.offset)
+                            ? Math.max(0, item.offset)
+                            : 0,
+                    },
+                ];
+            })
+            : [];
+        hits.push({
+            path: path.trim(),
+            score: typeof record.score === "number" && Number.isFinite(record.score)
+                ? record.score
+                : 0,
+            snippets,
+        });
+    }
+    return hits;
+}
+function resultsFromRecord(record) {
+    if (!record)
+        return [];
+    const direct = normalizeHits(record.results);
+    if (direct.length > 0)
+        return direct;
+    const structured = resultsFromRecord(asRecord(record.structuredContent));
+    if (structured.length > 0)
+        return structured;
+    const content = record.content;
+    if (!Array.isArray(content))
+        return [];
+    for (const item of content) {
+        const entry = asRecord(item);
+        if (typeof entry?.text !== "string")
+            continue;
+        const nested = resultsFromRecord(asRecord(parseJson(entry.text)));
+        if (nested.length > 0)
+            return nested;
+    }
+    return [];
+}
+export function notesSearchHitsFromOutput(output) {
+    return resultsFromRecord(asRecord(parseJson(output)));
+}
+export function fileNameFromPath(path) {
+    return path.split("/").at(-1) || path;
+}
+export function editorPositionFromOffset(source, offset) {
+    const clamped = Math.max(0, Math.min(offset, source.length));
+    const before = source.slice(0, clamped);
+    const line = before.split("\n").length - 1;
+    const ch = before.length - (before.lastIndexOf("\n") + 1);
+    return { line, ch };
+}
+export async function openNotesSearchHit(app, hit, snippet) {
+    const file = app.vault.getAbstractFileByPath(hit.path);
+    if (!(file instanceof TFile))
+        return;
+    const selected = app.workspace.getMostRecentLeaf() ?? app.workspace.activeLeaf;
+    const leaf = selected && selected.view instanceof FileView
+        ? selected
+        : app.workspace.getLeaf("tab");
+    await leaf.openFile(file);
+    app.workspace.activeLeaf = leaf;
+    app.workspace.revealLeaf(leaf);
+    if (!snippet || !(leaf.view instanceof TextFileView))
+        return;
+    try {
+        const source = await app.vault.cachedRead(file);
+        leaf.view.editor.setCursor(editorPositionFromOffset(source, snippet.offset));
+    }
+    catch {
+        // Opening the file is enough when the editor is not ready.
+    }
+}
+export function searchToolResultProps(props) {
+    return notesSearchHitsFromOutput(props.output);
+}

package/dist/search-tool-result.svelte

@@ -0,0 +1,55 @@
+<script lang="ts">
+  import type { AgentResultViewProps } from "@lapis-notes/api";
+  import type { App } from "@lapis-notes/api";
+  import {
+    fileNameFromPath,
+    notesSearchHitsFromOutput,
+    openNotesSearchHit,
+    type NotesSearchHit,
+    type NotesSearchSnippet,
+  } from "./search-tool-result";
+  import "./search-tool-result.css";
+
+  let {
+    app,
+    output,
+  }: AgentResultViewProps<App> = $props();
+
+  const hits = $derived(notesSearchHitsFromOutput(output));
+
+  async function openHit(
+    hit: NotesSearchHit,
+    snippet?: NotesSearchSnippet,
+  ): Promise<void> {
+    await openNotesSearchHit(app, hit, snippet);
+  }
+</script>
+
+<div data-ui-component="search-tool-result">
+  {#if hits.length === 0}
+    <p data-ui-part="empty">No matching notes.</p>
+  {: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)}`}
+          onclick={() => void openHit(hit)}
+        >
+          <span data-ui-part="file-label">{fileNameFromPath(hit.path)}</span>
+          <span data-ui-part="file-path">{hit.path}</span>
+        </button>
+        {#each hit.snippets as snippet, index (`${hit.path}:${snippet.offset}:${index}`)}
+          <button
+            type="button"
+            data-ui-part="snippet"
+            onclick={() => void openHit(hit, snippet)}
+          >
+            <span data-ui-part="snippet-text">{snippet.text}</span>
+          </button>
+        {/each}
+      </div>
+    {/each}
+  {/if}
+</div>

package/dist/search-tool-result.svelte.d.ts

@@ -0,0 +1,6 @@
+import type { AgentResultViewProps } from "@lapis-notes/api";
+import type { App } from "@lapis-notes/api";
+import "./search-tool-result.css";
+declare const SearchToolResult: import("svelte").Component<AgentResultViewProps<App>, {}, "">;
+type SearchToolResult = ReturnType<typeof SearchToolResult>;
+export default SearchToolResult;

package/dist/search-view-type.d.ts

@@ -0,0 +1 @@
+export declare const SearchViewType = "search";

package/dist/search-view-type.js

@@ -0,0 +1 @@
+export const SearchViewType = "search";

package/dist/search-view.d.ts

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

package/dist/search-view.js

@@ -0,0 +1,48 @@
+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;
+    constructor(leaf) {
+        super(leaf);
+    }
+    getViewType() {
+        return SearchViewType;
+    }
+    getDisplayText() {
+        return "Search";
+    }
+    getIcon() {
+        return "search";
+    }
+    onOpen() {
+        return Promise.resolve();
+    }
+    onClose() {
+        return Promise.resolve();
+    }
+    onload() {
+        this.component = mount(SearchPanel, {
+            target: this.containerEl,
+            props: {
+                app: this.app,
+                initialQuery: typeof this.getState()["query"] === "string"
+                    ? this.getState()["query"]
+                    : "",
+            },
+        });
+    }
+    async setState(state) {
+        await super.setState(state);
+        if (typeof state["query"] === "string") {
+            this.component?.setSearchQuery?.(state["query"]);
+        }
+    }
+    onunload() {
+        if (this.component)
+            void unmount(this.component);
+        this.component = null;
+    }
+}

package/dist/styles.css

@@ -0,0 +1,2 @@
+@import "./search-panel.css";
+@import "./search-tool-result.css";

package/manifest.json

@@ -0,0 +1,28 @@
+{
+  "id": "search",
+  "name": "Search",
+  "version": "0.1.0",
+  "minAppVersion": "0.1.0",
+  "description": "Search files, metadata, tags, and note content.",
+  "author": "Lapis Notes",
+  "lapis": {
+    "manifestVersion": 1,
+    "source": "official",
+    "locked": false,
+    "enabledByDefault": true,
+    "runtime": {
+      "entries": {
+        "workspace": {
+          "path": "main.mjs",
+          "format": "esm",
+          "sharedDependencies": [
+            "@lapis-notes/api",
+            "@lapis-notes/api/agent-skills",
+            "@lapis-notes/api/agent-tools"
+          ],
+          "requiresReloadOnUpdate": false
+        }
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@lapis-notes/search",
+  "version": "0.1.0",
+  "description": "Lapis Notes vault search plugin",
+  "license": "AGPL-3.0-or-later",
+  "type": "module",
+  "files": [
+    "dist",
+    "manifest.json",
+    "styles.css",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE.md",
+    "!dist/**/*.test.*",
+    "!dist/**/*.spec.*"
+  ],
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "svelte": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./agent-tools": {
+      "types": "./dist/agent-tools.d.ts",
+      "import": "./dist/agent-tools.js",
+      "default": "./dist/agent-tools.js"
+    },
+    "./manifest.json": "./manifest.json",
+    "./styles.css": "./styles.css"
+  },
+  "dependencies": {
+    "@lapis-notes/api": "^0.1.0",
+    "@lapismd/design-core": "^0.1.0",
+    "@lucide/svelte": "^0.523.0"
+  },
+  "peerDependencies": {
+    "@codemirror/language": "^6.11.1",
+    "@codemirror/state": "^6.4.1",
+    "@codemirror/view": "^6.35.0",
+    "svelte": "^5.0.0"
+  },
+  "devDependencies": {
+    "@sveltejs/package": "^2.5.0",
+    "@sveltejs/vite-plugin-svelte": "^5.1.1",
+    "@tsconfig/svelte": "^5.0.5",
+    "publint": "^0.3.12",
+    "svelte": "^5.38.2",
+    "svelte-check": "^4.3.1",
+    "typescript": "~5.8.3",
+    "vite": "^6.4.2",
+    "vitest": "^4.1.8"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lapismd/lapis-plugins.git",
+    "directory": "packages/search"
+  },
+  "homepage": "https://github.com/lapismd/lapis-plugins/tree/main/packages/search#readme",
+  "bugs": {
+    "url": "https://github.com/lapismd/lapis-plugins/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "pnpm run prepack",
+    "check": "pnpm check:svelte && pnpm check:types",
+    "check:svelte": "svelte-check --tsconfig ./tsconfig.app.json --fail-on-warnings --output human",
+    "check:types": "tsc -p tsconfig.node.json --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "publint": "publint",
+    "pack": "pnpm pack --pack-destination ../../.release/npm"
+  }
+}

package/styles.css

@@ -0,0 +1 @@
+@import "./dist/styles.css";