@pify/search 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pifydev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,66 @@
+# @pify/search
+
+Fuzzy file finding and indexed content search for [pi](https://github.com/earendil-works/pi) — fast when a native index is available, and working when it is not.
+
+Part of the [Pify suite](https://github.com/pifydev). Install with [`pify install search`](https://github.com/pifydev/cli) or `pi install npm:@pify/search`.
+
+## Why
+
+pi's `find` and `grep` spawn a process and read the tree on every call. That is the right design for a one-shot command and the wrong one for an agent, which asks over and over inside a single session. An index built once and kept current answers the fiftieth question as fast as the first.
+
+The other half is the shape of the question. `find` wants a glob; people want *"the auth route file — you know the one"*. Fuzzy, typo-tolerant matching with results ranked by what you have actually been working on answers that; a glob does not.
+
+## Tools
+
+### `fffind`
+
+| Parameter | Type | Notes |
+|---|---|---|
+| `query` | string | Part of a name or path; typos tolerated |
+| `limit` | number, optional | Per page, default 20 |
+| `cursor` | string, optional | From a previous call |
+
+`worktre entr` finds `worktree/src/enter.ts`. Results are ranked: an exact filename beats a matching stem, which beats a prefix, which beats a directory that merely contains the query — and recently edited or git-modified files rise, because that is what you are probably looking for.
+
+### `ffgrep`
+
+| Parameter | Type | Notes |
+|---|---|---|
+| `pattern` | string | What to search for |
+| `mode` | `literal` \| `regex` \| `fuzzy` | Default `literal` |
+| `caseSensitive` | boolean, optional | Default false |
+| `limit` / `cursor` | | Paging, default 20 per page |
+
+Three modes because three different questions get asked: the exact string, a shape, and *"something like this"* for when you do not know how it is spelled.
+
+## Two engines, one interface
+
+**Fast path** — [`@ff-labs/fff-node`](https://github.com/dmtrKovalenko/fff), a Rust index with a live file watcher, typo-resistant matching, git status and frecency. It scans this whole suite in about 80ms. Installed as an *optional* dependency: if the platform binary lands, it is used.
+
+**Fallback** — pure TypeScript, no dependencies. A trigram index for content, a fuzzy scorer for paths, an `fs.watch` subscription to stay current. Slower, and it runs wherever pi runs.
+
+The fallback is the point. A native binary is a promise you cannot always keep: an unsupported platform, a locked-down install, a blocked postinstall — any of those, and a binary-only search extension is one that silently does nothing. `/search` says which engine is live.
+
+Both are checked against each other on a real tree (`test/live/engines.mjs`, 21/21): the same files found, the same literal matches, the same refusal to search `node_modules`, and cursors that advance rather than repeat.
+
+## How the content index works
+
+Every overlapping three-byte window of every text file is a *trigram*, packed into one number and mapped to the files containing it. A search extracts the trigrams its pattern must contain and intersects those posting lists, so only files that could match are ever read. (The design is [tgrep](https://github.com/microsoft/tgrep)'s, which reports up to 52× over ripgrep on very large trees.)
+
+The index only ever **narrows**; every surviving candidate is still matched for real, so a wrong candidate costs time and never correctness. The rule that makes it safe: a pattern with nothing indexable — `\d+`, a fuzzy query, one branch of an alternation that could match anywhere — reports "no candidate set is safe" and everything is read. Confusing *that* with "nothing matched" is how an index starts silently hiding results, so the two are different values throughout.
+
+## Ranking
+
+Frecency decays on a three-day half-life — an agent session is shorter and more concentrated than a human's week, so yesterday's file should not outrank today's. Every `read`, `edit` or `write` in the session counts as an access. History is capped at seven days and 128 timestamps per file, so the store cannot grow without bound.
+
+## pi's own tools are left alone
+
+This package adds two tools; it does not replace `find`, `grep` or `multi_grep`. Replacing them would put every search in the session behind whichever engine happened to load, and a fallback that is slower than the thing it replaced is not an improvement anyone asked for. Use `fffind`/`ffgrep` when a search is worth an index; the built-ins are still there when it is not.
+
+## Command
+
+`/search` — which engine is running, the indexed root, and how many files it holds.
+
+## License
+
+MIT © [Pify maintainers](https://github.com/pifydev)

package/extensions/search.ts

@@ -0,0 +1,186 @@
+/**
+ * @pify/search — fuzzy file finding and indexed content search for pi.
+ *
+ * pi's `find` and `grep` spawn a process and read the tree on every call.
+ * That is the right design for a one-shot command and the wrong one for an
+ * agent, which asks over and over inside a single session. An index built once
+ * and kept current answers the second question and the fiftieth from memory.
+ *
+ * Two engines behind one interface. The fast path is `@ff-labs/fff-node`, a
+ * Rust index with a live watcher, typo-resistant matching, git status and
+ * frecency — it scans this suite in about 80ms. The fallback is pure
+ * TypeScript with no dependencies, because a native binary is a promise you
+ * cannot always keep: an unsupported platform or a blocked postinstall would
+ * otherwise leave a search extension that does nothing.
+ *
+ * pi's own tools are left alone. Replacing `grep` and `find` would put every
+ * search in the session behind whichever engine loaded, and a fallback that is
+ * slower than the thing it replaced is not an improvement anyone asked for.
+ */
+import {
+  getAgentDir,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { StringEnum } from "@earendil-works/pi-ai";
+import { Type } from "typebox";
+
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+import { loadFff, type SearchEngine } from "../src/engine.ts";
+import { builtinEngine } from "../src/builtin.ts";
+import { parseHistory, pruneHistory, type History } from "../src/frecency.ts";
+import { formatFiles, formatMatches, formatStatus } from "../src/format.ts";
+
+const READY_TIMEOUT_MS = 20_000;
+
+export default function searchExtension(pi: ExtensionAPI) {
+  let engine: SearchEngine | null = null;
+  let starting: Promise<SearchEngine | null> | null = null;
+  let root = "";
+  let historyFile: string | null = null;
+
+  function historyPath(cwd: string): string {
+    const key = createHash("sha256").update(cwd.toLowerCase()).digest("hex").slice(0, 12);
+    return join(getAgentDir(), "pify-search", `${key}.json`);
+  }
+
+  function loadHistory(): History {
+    if (!historyFile) return {};
+    try {
+      return pruneHistory(parseHistory(readFileSync(historyFile, "utf8")), Date.now());
+    } catch {
+      return {};
+    }
+  }
+
+  function saveHistory(history: History): void {
+    if (!historyFile) return;
+    try {
+      mkdirSync(dirname(historyFile), { recursive: true });
+      writeFileSync(historyFile, `${JSON.stringify(pruneHistory(history, Date.now()))}\n`);
+    } catch {
+      // A history that cannot be written costs ranking, never a search.
+    }
+  }
+
+  /** Start once; every caller awaits the same start. */
+  async function ensureEngine(ctx: ExtensionContext): Promise<SearchEngine | null> {
+    if (engine) return engine;
+    if (!starting) {
+      root = ctx.cwd;
+      historyFile = historyPath(ctx.cwd);
+      starting = (async () => {
+        const fast = await loadFff(root);
+        const chosen =
+          fast ?? builtinEngine(root, { history: loadHistory(), onHistoryChange: saveHistory });
+        await chosen.ready(READY_TIMEOUT_MS);
+        engine = chosen;
+        return chosen;
+      })();
+    }
+    return starting;
+  }
+
+  // ── Tools ────────────────────────────────────────────────────────────
+
+  pi.registerTool({
+    name: "fffind",
+    label: "Find files",
+    description:
+      "Find files by name or path with fuzzy, typo-tolerant matching, ranked so the file you meant " +
+      "comes first — recently edited and git-modified files rank higher. Prefer this over find/ls " +
+      "when you know roughly what the file is called but not exactly where it is. Returns a cursor " +
+      "for the next page when there are more results.",
+    parameters: Type.Object({
+      query: Type.String({ description: "Part of the filename or path; typos are tolerated" }),
+      limit: Type.Optional(Type.Number({ description: "Results per page (default 20)" })),
+      cursor: Type.Optional(Type.String({ description: "Cursor from a previous call" })),
+    }),
+    async execute(_id, params: { query: string; limit?: number; cursor?: string }, _signal, _onUpdate, ctx) {
+      const active = await ensureEngine(ctx as ExtensionContext);
+      if (!active) throw new Error("No search engine available.");
+      const page = await active.find(params.query.trim(), {
+        limit: Math.min(100, Math.max(1, params.limit ?? 20)),
+        ...(params.cursor ? { cursor: params.cursor } : {}),
+      });
+      return {
+        content: [{ type: "text", text: formatFiles(page, params.query) }],
+        details: { total: page.total, cursor: page.cursor, engine: active.name },
+      };
+    },
+  });
+
+  pi.registerTool({
+    name: "ffgrep",
+    label: "Search contents",
+    description:
+      "Search file contents from an in-memory index rather than re-reading the tree. mode=literal " +
+      "(default) for an exact string, regex for a pattern, fuzzy when you are unsure of the exact " +
+      "wording. Prefer this over grep for repeated searches in one session. Returns a cursor for " +
+      "the next page when there are more matches.",
+    parameters: Type.Object({
+      pattern: Type.String({ description: "What to search for" }),
+      mode: Type.Optional(StringEnum(["literal", "regex", "fuzzy"] as const)),
+      caseSensitive: Type.Optional(Type.Boolean({ description: "Default false" })),
+      limit: Type.Optional(Type.Number({ description: "Matches per page (default 20)" })),
+      cursor: Type.Optional(Type.String({ description: "Cursor from a previous call" })),
+    }),
+    async execute(
+      _id,
+      params: { pattern: string; mode?: "literal" | "regex" | "fuzzy"; caseSensitive?: boolean; limit?: number; cursor?: string },
+      _signal,
+      _onUpdate,
+      ctx,
+    ) {
+      const active = await ensureEngine(ctx as ExtensionContext);
+      if (!active) throw new Error("No search engine available.");
+      const page = await active.grep(params.pattern, {
+        mode: params.mode ?? "literal",
+        caseInsensitive: params.caseSensitive !== true,
+        limit: Math.min(100, Math.max(1, params.limit ?? 20)),
+        ...(params.cursor ? { cursor: params.cursor } : {}),
+      });
+      return {
+        content: [{ type: "text", text: formatMatches(page, params.pattern, params.mode ?? "literal") }],
+        details: { total: page.total, cursor: page.cursor, engine: active.name },
+      };
+    },
+  });
+
+  // ── Frecency: what the session actually touched ──────────────────────
+
+  pi.on("tool_call", async (event) => {
+    const name = (event as { toolName?: string }).toolName;
+    if (name !== "read" && name !== "edit" && name !== "write") return undefined;
+    const path = (event as { input?: { path?: unknown } }).input?.path;
+    if (typeof path === "string" && engine?.touch) engine.touch(path);
+    return undefined;
+  });
+
+  // ── Lifecycle ────────────────────────────────────────────────────────
+
+  pi.on("session_start", async (_event, ctx) => {
+    // Indexing starts now rather than at the first search, so the first
+    // question is as fast as the fiftieth. Deliberately not awaited: a large
+    // tree must not hold up the session.
+    void ensureEngine(ctx);
+  });
+
+  pi.on("session_shutdown", async () => {
+    engine?.dispose();
+    engine = null;
+    starting = null;
+  });
+
+  pi.registerCommand("search", {
+    description: "Which search engine is running, and what it has indexed",
+    handler: async (_args, ctx) => {
+      if (!ctx.hasUI) return;
+      const active = await ensureEngine(ctx);
+      ctx.ui.notify(formatStatus(active, root), "info");
+    },
+  });
+}

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@pify/search",
+  "version": "0.1.0",
+  "description": "Fuzzy file finding and indexed content search for pi, with no native binary and no daemon",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi",
+    "pify",
+    "search",
+    "grep",
+    "fuzzy",
+    "trigram"
+  ],
+  "homepage": "https://github.com/pifydev/search#readme",
+  "bugs": {
+    "url": "https://github.com/pifydev/search/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pifydev/search.git"
+  },
+  "license": "MIT",
+  "author": "Pify maintainers",
+  "type": "module",
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "files": [
+    "extensions",
+    "src",
+    "skills",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions/search.ts"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "prepublishOnly": "npm run typecheck && npm test"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-ai": {
+      "optional": true
+    },
+    "@earendil-works/pi-coding-agent": {
+      "optional": true
+    },
+    "@earendil-works/pi-tui": {
+      "optional": true
+    },
+    "typebox": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@earendil-works/pi-ai": "^0.85.1",
+    "@earendil-works/pi-coding-agent": "^0.85.1",
+    "@earendil-works/pi-tui": "^0.85.1",
+    "@types/node": "^22.10.2",
+    "typebox": "^1.1.38",
+    "typescript": "^5.7.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@ff-labs/fff-node": "^0.10.6"
+  },
+  "optionalDependencies": {
+    "@ff-labs/fff-node": "^0.10.6"
+  }
+}

package/skills/search/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: search
+description: Use when looking for a file whose name you only half remember, or searching code for a string, symbol, or pattern — especially when you will search more than once in a session
+---
+
+# Searching this project
+
+`@pify/search` keeps an index in memory, so the second search in a session is
+as cheap as the first. Prefer it over `find` and `grep`, which re-read the tree
+every time they run.
+
+## Finding a file
+
+`fffind query="auth route"` — fuzzy and typo-tolerant. Give a fragment of the
+name rather than a guess at the full path: `worktre entr` finds
+`worktree/src/enter.ts`. Results are ranked, so the first one is usually the
+one you meant — recently edited and git-modified files rank higher.
+
+## Searching contents
+
+`ffgrep pattern="..."` with one of three modes:
+
+- `literal` (default) — an exact string. Use it when you know the spelling.
+- `regex` — a pattern. Use it for shapes, like `function\s+handle\w+`.
+- `fuzzy` — when you are unsure of the wording. Use it after a literal search
+  comes back empty, before concluding the thing does not exist.
+
+## Paging
+
+Both tools return a `cursor` when there is more. An empty first page means no
+match; a page with a cursor does **not** mean the whole answer — fetch the next
+page before concluding anything about how often something appears.
+
+## When not to use this
+
+Reading a file you already know the path of: use `read`. Listing one directory:
+use `ls`. This is for finding things.

package/src/builtin.ts

@@ -0,0 +1,228 @@
+/**
+ * The engine that needs nothing installed.
+ *
+ * Everything here is the pure modules wired to a disk: walk the tree once,
+ * hold the paths in memory, build a trigram index over the text files, and
+ * keep both current from a watcher. It is slower than the Rust one and it runs
+ * wherever pi runs, which is the whole point — a search extension that only
+ * works when a native binary installed is an extension that sometimes does
+ * nothing at all.
+ */
+
+import { readFileSync, readdirSync, statSync, watch, type FSWatcher } from "node:fs";
+import { join, relative } from "node:path";
+
+import type { ContentHit, FileHit, GrepOptions, Page, SearchEngine, FindOptions } from "./engine.ts";
+import { rankAndPage, type Candidate } from "./fuzzy.ts";
+import { buildMatcher, looksBinary, matchLines } from "./match.ts";
+import { TrigramIndex, planForLiteral, planForPatterns, planForRegex } from "./trigram.ts";
+import {
+  MAX_SEARCHABLE_BYTES,
+  includeFile,
+  indexContent,
+  normalizePath,
+  skipDirectory,
+} from "./walk.ts";
+import { frecencyOf, noteAccess, type History } from "./frecency.ts";
+
+interface Entry {
+  id: number;
+  path: string;
+  absolute: string;
+  size: number;
+  mtimeMs: number;
+}
+
+export interface BuiltinOptions {
+  /** Frecency history, owned by the caller so it can be persisted. */
+  history?: History;
+  onHistoryChange?: (history: History) => void;
+  /** Hard cap, so a wrong root cannot eat the session. */
+  maxFiles?: number;
+}
+
+export function builtinEngine(root: string, options: BuiltinOptions = {}): SearchEngine {
+  const entries = new Map<number, Entry>();
+  const byPath = new Map<string, number>();
+  const index = new TrigramIndex();
+  const watchers: FSWatcher[] = [];
+  const maxFiles = options.maxFiles ?? 50_000;
+  let history: History = options.history ?? {};
+  let nextId = 1;
+  let scanned = false;
+
+  function add(absolute: string, size: number, mtimeMs: number): void {
+    const path = normalizePath(relative(root, absolute));
+    if (!path || !includeFile(path)) return;
+    const existing = byPath.get(path);
+    const id = existing ?? nextId++;
+    entries.set(id, { id, path, absolute, size, mtimeMs });
+    byPath.set(path, id);
+
+    if (!indexContent(path, size)) {
+      index.remove(id);
+      return;
+    }
+    try {
+      const content = readFileSync(absolute, "utf8");
+      // A NUL byte is cheaper and more reliable than trusting an extension.
+      if (looksBinary(content)) index.remove(id);
+      else index.add(id, content);
+    } catch {
+      index.remove(id);
+    }
+  }
+
+  function drop(absolute: string): void {
+    const path = normalizePath(relative(root, absolute));
+    const id = byPath.get(path);
+    if (id === undefined) return;
+    byPath.delete(path);
+    entries.delete(id);
+    index.remove(id);
+  }
+
+  function scan(dir: string, depth = 0): void {
+    if (entries.size >= maxFiles || depth > 24) return;
+    let listing: string[];
+    try {
+      listing = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const name of listing) {
+      if (entries.size >= maxFiles) return;
+      const absolute = join(dir, name);
+      let stats;
+      try {
+        stats = statSync(absolute);
+      } catch {
+        continue;
+      }
+      if (stats.isDirectory()) {
+        if (skipDirectory(name)) continue;
+        scan(absolute, depth + 1);
+      } else if (stats.isFile()) {
+        add(absolute, stats.size, stats.mtimeMs);
+      }
+    }
+  }
+
+  function startWatching(): void {
+    try {
+      const watcher = watch(root, { recursive: true }, (_event, filename) => {
+        if (!filename) return;
+        const absolute = join(root, String(filename));
+        const parts = normalizePath(String(filename)).split("/");
+        if (parts.some((part) => skipDirectory(part))) return;
+        try {
+          const stats = statSync(absolute);
+          if (stats.isFile()) add(absolute, stats.size, stats.mtimeMs);
+        } catch {
+          // Gone: a delete, a rename away, or something we may not read.
+          drop(absolute);
+        }
+      });
+      watchers.push(watcher);
+    } catch {
+      // Recursive watching is not available everywhere; the index is then
+      // simply as fresh as the last scan, which is still useful.
+    }
+  }
+
+  function candidates(now: number): Candidate[] {
+    return [...entries.values()].map((entry) => ({
+      path: entry.path,
+      frecency: frecencyOf(history, entry.path, now),
+      mtimeMs: entry.mtimeMs,
+    }));
+  }
+
+  return {
+    name: "builtin",
+    async ready() {
+      if (!scanned) {
+        scan(root);
+        startWatching();
+        scanned = true;
+      }
+      return true;
+    },
+    async find(query: string, opts: FindOptions = {}): Promise<Page<FileHit>> {
+      const now = Date.now();
+      const page = rankAndPage(candidates(now), query, now, opts.limit ?? 20, opts.cursor);
+      return {
+        items: page.items.map((hit) => {
+          const id = byPath.get(hit.path);
+          const entry = id === undefined ? undefined : entries.get(id);
+          return { path: hit.path, score: hit.score, size: entry?.size, modifiedMs: entry?.mtimeMs };
+        }),
+        total: page.total,
+        cursor: page.cursor,
+      };
+    },
+    async grep(pattern: string, opts: GrepOptions = {}): Promise<Page<ContentHit>> {
+      const mode = opts.mode ?? "literal";
+      const caseInsensitive = opts.caseInsensitive ?? true;
+      const matcher = buildMatcher(pattern, mode, caseInsensitive);
+      if (!matcher) return { items: [], total: 0, cursor: null };
+
+      // Fuzzy matching has no required substring, so the index cannot narrow
+      // it; saying so honestly beats narrowing wrongly and losing matches.
+      const plan =
+        mode === "fuzzy"
+          ? { kind: "all" as const }
+          : planForPatterns([mode === "regex" ? planForRegex(pattern, caseInsensitive) : planForLiteral(pattern, caseInsensitive)]);
+      const narrowed = index.candidates(plan);
+
+      const hits: ContentHit[] = [];
+      const limit = opts.limit ?? 20;
+      const offset = Number.parseInt(opts.cursor ?? "0", 10);
+      const start = Number.isFinite(offset) && offset > 0 ? offset : 0;
+      // One page beyond what is asked for, so `total` can say whether there is
+      // more without reading the entire tree to find out.
+      const budget = start + limit + 1;
+
+      const searchIds = narrowed === null ? [...entries.keys()] : [...narrowed];
+      for (const id of searchIds) {
+        if (hits.length >= budget) break;
+        const entry = entries.get(id);
+        if (!entry || entry.size > MAX_SEARCHABLE_BYTES) continue;
+        if (opts.glob && !entry.path.includes(opts.glob.replace(/\*/g, ""))) continue;
+        let content: string;
+        try {
+          content = readFileSync(entry.absolute, "utf8");
+        } catch {
+          continue;
+        }
+        if (looksBinary(content)) continue;
+        for (const line of matchLines(content, matcher, budget - hits.length)) {
+          hits.push({ path: entry.path, line: line.line, text: line.text });
+        }
+      }
+
+      hits.sort((a, b) => a.path.localeCompare(b.path) || a.line - b.line);
+      const items = hits.slice(start, start + limit);
+      return { items, total: hits.length, cursor: start + items.length < hits.length ? String(start + items.length) : null };
+    },
+    touch(path: string) {
+      history = noteAccess(history, normalizePath(path), Date.now());
+      options.onHistoryChange?.(history);
+    },
+    indexed() {
+      return entries.size;
+    },
+    dispose() {
+      for (const watcher of watchers) {
+        try {
+          watcher.close();
+        } catch {
+          // already closed
+        }
+      }
+      watchers.length = 0;
+      entries.clear();
+      byPath.clear();
+    },
+  };
+}