Implement issue and patch list fuzzy finder — radicle-desktop

👉 Workflow runs 👉 Branch on GitHub

     rid: identity::RepoId,
     status: Option<types::cobs::query::PatchStatus>,
     skip: Option<usize>,
     // None: return all patches, `skip` is ignored.
     take: Option<usize>,
 ) -> Result<types::cobs::PaginatedQuery<Vec<models::patch::Patch>>, Error> {
     let profile = ctx.profile();
     let cursor = skip.unwrap_or(0);
     let take = take.unwrap_or(20);
     let aliases = profile.aliases();
     let patches = match status {
         None => sqlite_service.list(rid)?.collect::<Vec<_>>(),
         Some(s) => sqlite_service
             .list_by_status(rid, s.into())?
             .collect::<Vec<_>>(),
     };
     let more = cursor + take < patches.len();
     let patches = patches
         .into_iter()
         .map(|(id, patch)| models::patch::Patch::new(id, &patch, &aliases))
         .skip(cursor)
         .take(take)
         .collect::<Vec<_>>();
     match take {
         None => {
             let content = patches
                 .into_iter()
                 .map(|(id, patch)| models::patch::Patch::new(id, &patch, &aliases))
                 .collect::<Vec<_>>();
             Ok::<_, Error>(cobs::PaginatedQuery {
                 cursor: 0,
                 more: false,
                 content,
             })
         }
         Some(take) => {
             let more = cursor + take < patches.len();
             let content = patches
                 .into_iter()
                 .map(|(id, patch)| models::patch::Patch::new(id, &patch, &aliases))
                 .skip(cursor)
                 .take(take)
                 .collect::<Vec<_>>();
     Ok::<_, Error>(cobs::PaginatedQuery {
         cursor,
         more,
         content: patches,
     })
             Ok::<_, Error>(cobs::PaginatedQuery {
                 cursor,
                 more,
                 content,
             })
         }
     }
 }
 #[tauri::command]

 pub async fn get_diff(
     ctx: tauri::State<'_, AppState>,
     rid: identity::RepoId,
     options: radicle_types::cobs::diff::Options,
     options: radicle_types::cobs::diff::DiffOptions,
 ) -> Result<types::diff::Diff, Error> {
     ctx.get_diff(rid, options)
 }

     rid: RepoId,
     base: git::Oid,
     head: git::Oid,
 ) -> Result<types::cobs::Stats, Error> {
 ) -> Result<types::diff::Stats, Error> {
     ctx.diff_stats(rid, base, head)
 }

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 export type DiffOptions = {
   base: string;
   head: string;
   unified: number | null;
   highlight: boolean | null;
 };

 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
 export type Stats = {
   files_changed: number;
   insertions: number;
   deletions: number;
 };

     pub content: T,
 }
 #[derive(TS, Serialize)]
 #[ts(export)]
 #[ts(export_to = "cob/")]
 pub struct Stats {
     pub files_changed: usize,
     pub insertions: usize,
     pub deletions: usize,
 }
 impl Stats {
     pub fn new(stats: &radicle_surf::diff::Stats) -> Self {
         Self {
             files_changed: stats.files_changed,
             insertions: stats.insertions,
             deletions: stats.deletions,
         }
     }
 }
 pub mod query {
     use serde::{Deserialize, Serialize};

 use radicle::git;
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 #[derive(Serialize, Deserialize)]
 pub struct Options {
 #[derive(TS, Serialize, Deserialize)]
 #[ts(export)]
 #[ts(export_to = "cob/")]
 pub struct DiffOptions {
     #[ts(as = "String")]
     pub base: git::Oid,
     #[ts(as = "String")]
     pub head: git::Oid,
     pub unified: Option<u32>,
     pub highlight: Option<bool>,

 use radicle::{git, identity};
 use crate::cobs;
 use crate::diff;
 use crate::diff::Diff;
 use crate::error::Error;
 use crate::repo::{self, RepoCount};

         rid: identity::RepoId,
         base: git::Oid,
         head: git::Oid,
     ) -> Result<cobs::Stats, Error> {
     ) -> Result<diff::Stats, Error> {
         let profile = self.profile();
         let repo = radicle_surf::Repository::open(storage::git::paths::repository(
             &profile.storage,

         let diff = repo.diff(base.id, commit.id)?;
         let stats = diff.stats();
         Ok::<_, Error>(cobs::Stats::new(stats))
         Ok::<_, Error>(diff::Stats::new(stats))
     }
     fn repo_info(

         })
     }
     fn get_diff(&self, rid: identity::RepoId, options: cobs::diff::Options) -> Result<Diff, Error> {
     fn get_diff(
         &self,
         rid: identity::RepoId,
         options: cobs::diff::DiffOptions,
     ) -> Result<Diff, Error> {
         let unified = options.unified.unwrap_or(5);
         let highlight = options.highlight.unwrap_or(true);
         let profile = self.profile();

 #[derive(Serialize, Deserialize)]
 struct DiffBody {
     pub rid: identity::RepoId,
     pub options: types::cobs::diff::Options,
     pub options: types::cobs::diff::DiffOptions,
 }
 async fn diff_handler(

 struct PatchesBody {
     pub rid: identity::RepoId,
     pub skip: Option<usize>,
     pub take: Option<usize>,
     pub take: Option<isize>,
     pub status: Option<types::cobs::query::PatchStatus>,
 }

         "hast-util-to-dom": "^4.0.1",
         "keyux": "^0.11.1",
         "lodash": "^4.17.21",
         "lru-cache": "^11.1.0",
         "marked": "^15.0.7",
         "marked-emoji": "^2.0.0",
         "marked-footnote": "^1.2.4",

       "integrity": "sha512-kkIp7XSkP78ZxJEsSxW3712C6teJVoeHHwgo9zJ380de7IYyJ2ISlxojcH2pC5OFLewESmnRi/+XCDIEEVyoug==",
       "dev": true
     },
     "node_modules/lru-cache": {
       "version": "11.1.0",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.1.0.tgz",
       "integrity": "sha512-QIXZUBJUx+2zHUdQujWejBkcD9+cs94tLn0+YL8UrCh+D5sCXZ4c7LaEH48pNwRY3MLDgqUFyhlCyjJPf1WP0A==",
       "dev": true,
       "license": "ISC",
       "engines": {
         "node": "20 || >=22"
       }
     },
     "node_modules/magic-string": {
       "version": "0.30.17",
       "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.17.tgz",

 <script lang="ts">
   import type { Commit } from "@bindings/repo/Commit";
   import type { Diff } from "@bindings/diff/Diff";
   import type { CodeComments } from "./Diff.svelte";
   import type { Revision } from "@bindings/cob/patch/Revision";
   import { invoke } from "@app/lib/invoke";
   import { cachedGetDiff, cachedListCommits } from "@app/lib/invoke";
   import { pluralize } from "@app/lib/utils";
   import Changeset from "@app/components/Changeset.svelte";

   const isActiveCommit = (commitId: string) => selectedCommit === commitId;
   const isTeaserDisabled = (commitId: string) =>
     selectedCommit ? selectedCommit !== commitId : false;
   async function loadHighlightedDiff(rid: string, base: string, head: string) {
     return invoke<Diff>("get_diff", {
       rid,
       options: {
         base,
         head,
         unified: 3,
         highlight: true,
       },
     });
   }
   async function loadCommits(rid: string, base: string, head: string) {
     return invoke<Commit[]>("list_commits", {
       rid,
       base,
       head,
     });
   }
 </script>
 <style>

 </div>
 <div class:hide={hideChanges}>
   {#await loadCommits(rid, revision.base, revision.head) then commits}
   {#await cachedListCommits(rid, revision.base, revision.head) then commits}
     <div style:margin-bottom="1rem">
       <CommitsContainer>
         {#snippet leftHeader()}

     </div>
   {/await}
   {#await loadHighlightedDiff(rid, base, head)}
   {#await cachedGetDiff(rid, { base, head, unified: 3, highlight: true })}
     <span class="txt-small">Loading…</span>
   {:then diff}
     <Changeset expanded={filesExpanded} {head} {diff} {codeComments} />

 <script lang="ts">
   import type { Stats } from "@bindings/cob/Stats";
   import type { Stats } from "@bindings/diff/Stats";
   interface Props {
     stats: Stats;

       | "eye"
       | "face"
       | "file"
       | "filter"
       | "home"
       | "info"
       | "inbox"

     <path d="M4 2H9V3L4 3V2Z" />
     <path d="M13 6V13H12V6L13 6Z" />
     <path d="M4 3V13H3L3 3L4 3Z" />
   {:else if name === "filter"}
     <path d="M3 2L13 2V3L3 3V2Z" />
     <path d="M13 3L14 3V4L13 4V3Z" />
     <path d="M12 4L13 4V5H12V4Z" />
     <path d="M11 5L12 5V7H11V5Z" />
     <path d="M5 5H4V7H5V5Z" />
     <path d="M10 7L11 7V9H10V7Z" />
     <path d="M6 7L5 7L5 9H6V7Z" />
     <path d="M9 9L10 9L10 13L9 13L9 9Z" />
     <path d="M7 9H6V12H7V9Z" />
     <path d="M2 3L3 3L3 4H2L2 3Z" />
     <path d="M3 4H4L4 5L3 5L3 4Z" />
     <path d="M8 13H9L9 14H8V13Z" />
     <path d="M6 4L12 4V5L6 5V4Z" />
     <path d="M7 12H8L8 13H7L7 12Z" />
   {:else if name === "home"}
     <path d="M7 1.50003H9V2.50003H7V1.50003Z" />
     <path d="M6 2.50003L7 2.50003V3.50003H6V2.50003Z" />

   } from "@app/lib/utils";
   import { push } from "@app/lib/router";
   import Border from "./Border.svelte";
   import Icon from "./Icon.svelte";
   import Id from "./Id.svelte";
   import InlineTitle from "./InlineTitle.svelte";

   import NodeId from "./NodeId.svelte";
   interface Props {
     compact?: boolean;
     focussed?: boolean;
     issue: Issue;
     rid: string;
     status: IssueStatus;
     selected?: boolean;
     compact?: boolean;
     status: IssueStatus;
   }
   const {
     compact = false,
     focussed,
     issue,
     rid,
     status,
     selected = false,
     compact = false,
     status,
   }: Props = $props();
 </script>

   .issue-teaser {
     display: flex;
     align-items: center;
     justify-content: space-between;
     gap: 0.25rem;
     min-height: 5rem;
     background-color: var(--color-background-float);

   }
 </style>
 <!-- svelte-ignore a11y_click_events_have_key_events -->
 <div
   tabindex="0"
   role="button"
   class="issue-teaser"
   class:selected
   style:align-items="flex-start"
   onclick={() => {
     void push({ resource: "repo.issue", rid, issue: issue.id, status });
   }}>
 {#snippet issueSnippet()}
   <div class="global-flex" style:align-items="flex-start">
     <div
       class="global-counter status"

     </div>
   </div>
   <div class="global-flex">
   <div class="global-flex" style:margin-left="auto">
     {#if !compact}
       {#each issue.labels as label}
         <Label {label} />

       </div>
     {/if}
   </div>
 </div>
 {/snippet}
 {#if focussed}
   <Border
     styleBackgroundColor="var(--color-background-float)"
     styleDisplay="flex"
     styleAlignItems="flex-start"
     styleMinHeight="5rem"
     stylePadding="1rem"
     variant="secondary">
     {@render issueSnippet()}
   </Border>
 {:else}
   <!-- svelte-ignore a11y_click_events_have_key_events -->
   <div
     tabindex="0"
     role="button"
     class="issue-teaser"
     class:selected
     style:align-items="flex-start"
     onclick={() => {
       void push({ resource: "repo.issue", rid, issue: issue.id, status });
     }}>
     {@render issueSnippet()}
   </div>
 {/if}

     patchStatusBackgroundColor,
     patchStatusColor,
   } from "@app/lib/utils";
   import { invoke } from "@app/lib/invoke";
   import { cachedDiffStats } from "@app/lib/invoke";
   import { push } from "@app/lib/router";
   import DiffStatBadge from "@app/components/DiffStatBadge.svelte";

 <script lang="ts">
   import type { FormEventHandler } from "svelte/elements";
   import type { Snippet } from "svelte";
   import { onMount } from "svelte";
   import Border from "./Border.svelte";
   import type { FormEventHandler } from "svelte/elements";
   interface Props {
     name?: string;
     placeholder?: string;
     value?: string;
     type?: string;
     autofocus?: boolean;
     autoselect?: boolean;
     disabled?: boolean;
     onSubmit?: () => void;
     keyShortcuts?: string;
     left?: Snippet;
     name?: string;
     onDismiss?: () => void;
     valid?: boolean;
     onFocus?: () => void;
     onSubmit?: () => void;
     oninput?: FormEventHandler<HTMLInputElement>;
     keyShortcuts?: string;
     placeholder?: string;
     type?: string;
     valid?: boolean;
     value?: string;
   }
   /* eslint-disable prefer-const */
   let {
     name,
     placeholder,
     value = $bindable(undefined),
     type = "text",
     autofocus = false,
     autoselect = false,
     disabled = false,
     onSubmit,
     keyShortcuts,
     left,
     name,
     onDismiss,
     valid = true,
     onFocus,
     onSubmit,
     oninput,
     keyShortcuts,
     placeholder,
     type = "text",
     valid = true,
     value = $bindable(undefined),
   }: Props = $props();
   /* eslint-enable prefer-const */

     height: 100%;
     margin: 0;
     height: 32px;
     padding: 0.25rem 0.75rem;
     border: 0;
   }
   input::placeholder {

 <Border
   variant={valid ? (focussed ? "secondary" : "ghost") : "danger"}
   styleWidth="100%">
   {@render left?.()}
   <input
     style:padding={left ? "0.25rem 0.75rem 0.25rem 0" : "0.25rem 0.75rem"}
     aria-keyshortcuts={keyShortcuts}
     onfocus={() => {
       if (onFocus) {
         onFocus();
       }
       focussed = true;
     }}
     onblur={() => {

 import { LRUCache } from "lru-cache";
 export function cached<Args extends unknown[], V>(
   f: (...args: Args) => Promise<V>,
   makeKey: (...args: Args) => string,
   options?: LRUCache.Options<string, { value: V }, unknown>,
 ): (...args: Args) => Promise<V> {
   const cache = new LRUCache(options || { max: 500 });
   return async function (...args: Args): Promise<V> {
     const key = makeKey(...args);
     const cached = cache.get(key);
     if (cached === undefined) {
       const value = await f(...args);
       cache.set(key, { value });
       return value;
     } else {
       return cached.value;
     }
   };
 }

 import type { Commit } from "@bindings/repo/Commit";
 import type { Diff } from "@bindings/diff/Diff";
 import type { DiffOptions } from "@bindings/cob/DiffOptions";
 import type { Stats } from "@bindings/diff/Stats";
 import * as tauri from "@tauri-apps/api/core";
 import { cached } from "@app/lib/cached";
 export async function invoke<T = null>(
   cmd: string,
   args?: tauri.InvokeArgs,
   options?: tauri.InvokeOptions,
 ): Promise<T> {
   return withTestBackend<T>(tauri.invoke, cmd, args, options);
 }
 async function withTestBackend<T>(
   fn: (
     cmd: string,
     args?: tauri.InvokeArgs,
     options?: tauri.InvokeOptions,
   ) => Promise<T>,
   cmd: string,
   args?: tauri.InvokeArgs,
   options?: tauri.InvokeOptions,
 ) {
   if (window.__TAURI_INTERNALS__) {
     return tauri.invoke(cmd, args, options);
     return fn(cmd, args, options);
   } else {
     return fetch(`http://127.0.0.1:8081/${cmd}`, {
       method: "POST",

   }
 }
 async function getDiff(rid: string, options: DiffOptions): Promise<Diff> {
   return withTestBackend(tauri.invoke, "get_diff", {
     rid,
     options,
   });
 }
 export const cachedGetDiff = cached(
   getDiff,
   (...[rid, options]) =>
     `get_diff:${rid}:${JSON.stringify(options, Object.keys(options).sort())}`,
   { max: 10_000 },
 );
 async function listCommits(
   rid: string,
   base: string,
   head: string,
 ): Promise<Commit[]> {
   return withTestBackend(tauri.invoke, "list_commits", { rid, base, head });
 }
 export const cachedListCommits = cached(
   listCommits,
   (...[rid, base, head]) => `list_commits:${rid}:${base}:${head}`,
   { max: 5_000 },
 );
 async function diffStats(
   rid: string,
   base: string,
   head: string,
 ): Promise<Stats> {
   return withTestBackend(tauri.invoke, "diff_stats", {
     rid,
     base,
     head,
   });
 }
 export const cachedDiffStats = cached(
   diffStats,
   (...[rid, base, head]) => `diff_stats:${rid}:${base}:${head}`,
   { max: 10_000 },
 );
 export async function writeToClipboard(
   text: string,
   opts?: {