@aaroncql/pim-agent 0.2.0 → 0.4.0

package/README.md

@@ -1,6 +1,11 @@
 <!-- omit in toc -->
 # PIM - Pi IMproved
 
+[![npm version](https://img.shields.io/npm/v/@aaroncql/pim-agent?style=flat-square)](https://www.npmjs.com/package/@aaroncql/pim-agent)
+[![npm downloads](https://img.shields.io/npm/dm/@aaroncql/pim-agent?style=flat-square)](https://www.npmjs.com/package/@aaroncql/pim-agent)
+[![license](https://img.shields.io/npm/l/@aaroncql/pim-agent?style=flat-square)](./LICENSE)
+[![Bun](https://img.shields.io/badge/runtime-Bun-black?logo=bun&style=flat-square)](https://bun.com)
+
 _**Pim is to Pi what Vim is to Vi.**_
 
 A Bun-native extension pack for [Pi](https://pi.dev/): web access, subagents, revamped core tools, ANSI-compatible themes, fzf-style completions, Telegram mode, and more. Preliminary score of [37.8% on Terminal-Bench 2.0](#terminal-bench-20) with locally hosted Qwen3.6-35B, rivalling Claude Code + Sonnet 4.5.
@@ -19,6 +24,7 @@ A Bun-native extension pack for [Pi](https://pi.dev/): web access, subagents, re
   - [Setup](#setup)
   - [Commands](#commands)
   - [Features](#features)
+- [Changelog](#changelog)
 - [Developing](#developing)
 
 ![Pim Demo](https://raw.githubusercontent.com/AaronCQL/pim-agent/refs/heads/main/assets/demo.webp)
@@ -226,10 +232,14 @@ For development, run standalone with `pim --mode telegram` instead.
 
 - ⏰ **Scheduled tasks** - your bot can create one-time, interval, or cron-based tasks that fire automatically; ask your bot to schedule something.
 - 👀 **Live progress logs** - use `/logs` to choose what you see while the agent works: final replies, tool use, intermediate text, or thinking.
-- 📝 **Markdown formatting** - replies render Markdown out of the box, including tables converted to vertical lists for Telegram.
+- 📝 **Rich Markdown** - supports Telegram's [rich text formatting](https://telegram.org/blog/watch-apps-and-more#obscenely-rich-text-formatting-for-bots) with full markdown and LaTeX math support.
 - 📎 **Rich media** - send photos, documents, videos, audio, and voice messages directly in chat; your bot can also send files back to you.
 - 🧵 **Thread-specific prompts** - each chat (or thread) gets its own session and optional instructions; ask your bot to modify its instructions.
 
+## Changelog
+
+See [CHANGELOG.md](./CHANGELOG.md) for release notes.
+
 ## Developing
 
 ```sh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aaroncql/pim-agent",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "A Bun-native extension pack for Pi: web access, subagents, revamped core tools, ANSI-compatible themes, fzf-style completions, Telegram mode, and more.",
   "license": "MIT",
   "type": "module",
@@ -48,16 +48,16 @@
     "@earendil-works/pi-coding-agent": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.76.0",
+    "@earendil-works/pi-coding-agent": "0.79.2",
     "@types/bun": "latest",
-    "@typescript/native-preview": "^7.0.0-dev.20260505.1",
-    "oxlint": "^1.62.0",
-    "prettier": "^3.8.3"
+    "@typescript/native-preview": "^7.0.0-dev.20260612.1",
+    "oxlint": "^1.69.0",
+    "prettier": "^3.8.4"
   },
   "dependencies": {
     "diff": "^9.0.0",
     "fzf": "^0.5.2",
-    "grammy": "^1.42.0",
+    "grammy": "^1.44.0",
     "ignore": "^7.0.5",
     "ky": "^2.0.2"
   }

package/src/extensions/apply-patch/coordinator.ts

@@ -2,28 +2,46 @@ const EDIT_TOOL = "edit";
 const APPLY_PATCH_TOOL = "apply_patch";
 
 /**
- * Pure reconcile over the active-tool list. Single-slot swap:
- *  - If neither `edit` nor `apply_patch` is active, no-op (respect user opt-out).
- *  - Otherwise keep exactly one in the same position: `apply_patch` when the
- *    model is GPT/Codex-family, else `edit`. All other active tools are
- *    preserved in order.
+ * Pure reconcile over available and active tool lists. Single-slot swap:
+ *  - If exactly one of `edit` or `apply_patch` is available, use that tool.
+ *  - If both are available, keep exactly one in the same position: `apply_patch`
+ *    when the model is GPT/Codex-family, else `edit`.
+ *  - If neither is active and availability does not force a choice, no-op
+ *    (respect user opt-out). All other active tools are preserved in order.
  *
  * Returns the same array reference when nothing changes so callers can skip the
  * prompt-rebuilding `setActiveTools` call.
  */
 export function computeActiveTools(
+  available: readonly string[],
   active: readonly string[],
   isGpt: boolean
 ): readonly string[] {
   const hasEdit = active.includes(EDIT_TOOL);
   const hasApplyPatch = active.includes(APPLY_PATCH_TOOL);
+  const canEdit = available.includes(EDIT_TOOL);
+  const canApplyPatch = available.includes(APPLY_PATCH_TOOL);
 
   if (!hasEdit && !hasApplyPatch) {
+    if (canEdit !== canApplyPatch) {
+      return [...active, canEdit ? EDIT_TOOL : APPLY_PATCH_TOOL];
+    }
+    return active;
+  }
+
+  if (!canEdit && !canApplyPatch) {
     return active;
   }
 
-  const desired = isGpt ? APPLY_PATCH_TOOL : EDIT_TOOL;
-  const drop = isGpt ? EDIT_TOOL : APPLY_PATCH_TOOL;
+  const desired =
+    canEdit && !canApplyPatch
+      ? EDIT_TOOL
+      : canApplyPatch && !canEdit
+        ? APPLY_PATCH_TOOL
+        : isGpt
+          ? APPLY_PATCH_TOOL
+          : EDIT_TOOL;
+  const drop = desired === EDIT_TOOL ? APPLY_PATCH_TOOL : EDIT_TOOL;
 
   if (active.includes(desired) && !active.includes(drop)) {
     return active;

package/src/extensions/apply-patch/index.ts

@@ -58,7 +58,8 @@ export default function (pi: ExtensionAPI): void {
 
   const reconcile = (isGpt: boolean): void => {
     const active = pi.getActiveTools();
-    const next = computeActiveTools(active, isGpt);
+    const available = pi.getAllTools().map((tool) => tool.name);
+    const next = computeActiveTools(available, active, isGpt);
     if (next !== active) {
       pi.setActiveTools([...next]);
     }

package/src/extensions/file-picker/FilePickerSuggestionEngine.ts

@@ -0,0 +1,14 @@
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+
+export type RankFilePickerOptions = {
+  readonly limit?: number;
+  readonly signal?: AbortSignal;
+};
+
+export type FilePickerSuggestionEngine = {
+  readonly refreshRelative: () => Promise<void>;
+  readonly rank: (
+    query: string,
+    options: RankFilePickerOptions
+  ) => Promise<readonly AutocompleteItem[] | undefined>;
+};

package/src/extensions/file-picker/InProcessFilePickerSuggestionEngine.ts

@@ -0,0 +1,52 @@
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+import type { FileCandidate } from "./catalog";
+import type {
+  FilePickerSuggestionEngine,
+  RankFilePickerOptions,
+} from "./FilePickerSuggestionEngine";
+import { rank } from "./ranker";
+
+export type InProcessFilePickerSuggestionEngineOptions = {
+  readonly loadRelativeCatalog: () => Promise<readonly FileCandidate[]>;
+};
+
+export class InProcessFilePickerSuggestionEngine implements FilePickerSuggestionEngine {
+  private cachedRelative: readonly FileCandidate[] | undefined;
+  private refresh: Promise<void> | undefined;
+
+  public constructor(
+    private readonly options: InProcessFilePickerSuggestionEngineOptions
+  ) {}
+
+  public refreshRelative(): Promise<void> {
+    this.refresh ??= this.options
+      .loadRelativeCatalog()
+      .then((catalog) => {
+        this.cachedRelative = catalog;
+      })
+      .catch(() => {
+        if (this.cachedRelative === undefined) {
+          this.cachedRelative = [];
+        }
+      })
+      .finally(() => {
+        this.refresh = undefined;
+      });
+
+    return this.refresh;
+  }
+
+  public async rank(
+    query: string,
+    options: RankFilePickerOptions
+  ): Promise<readonly AutocompleteItem[] | undefined> {
+    if (options.signal?.aborted === true) {
+      return [];
+    }
+
+    return rank(query, {
+      cachedRelative: this.cachedRelative,
+      limit: options.limit,
+    });
+  }
+}

package/src/extensions/file-picker/WorkerFilePickerSuggestionEngine.ts

@@ -0,0 +1,268 @@
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+import type {
+  FilePickerSuggestionEngine,
+  RankFilePickerOptions,
+} from "./FilePickerSuggestionEngine";
+import type {
+  FilePickerWorkerRequest,
+  FilePickerWorkerResponse,
+} from "./filePickerWorkerMessages";
+
+type PendingRefresh = {
+  readonly resolve: () => void;
+};
+
+type RankRequest = {
+  readonly id: number;
+  readonly query: string;
+  readonly limit: number | undefined;
+  readonly resolve: (items: readonly AutocompleteItem[] | undefined) => void;
+  readonly reject: (error: unknown) => void;
+  readonly signal: AbortSignal | undefined;
+  readonly abortListener: (() => void) | undefined;
+  settled: boolean;
+};
+
+export class WorkerFilePickerSuggestionEngine implements FilePickerSuggestionEngine {
+  private worker: Worker | undefined;
+  private nextRequestId = 0;
+  private refresh: Promise<void> | undefined;
+  private activeRank: RankRequest | undefined;
+  private queuedRank: RankRequest | undefined;
+  private readonly pendingRefreshes = new Map<number, PendingRefresh>();
+
+  public constructor(private readonly root: string) {}
+
+  public refreshRelative(): Promise<void> {
+    this.refresh ??= this.sendRefreshRelative().finally(() => {
+      this.refresh = undefined;
+    });
+    return this.refresh;
+  }
+
+  public rank(
+    query: string,
+    options: RankFilePickerOptions
+  ): Promise<readonly AutocompleteItem[] | undefined> {
+    if (options.signal?.aborted === true) {
+      return Promise.resolve([]);
+    }
+
+    const id = this.nextRequestId++;
+    return new Promise((resolve, reject) => {
+      let request: RankRequest;
+      const abortListener = (): void => {
+        this.abortRank(request);
+      };
+      request = {
+        id,
+        query,
+        limit: options.limit,
+        resolve,
+        reject,
+        signal: options.signal,
+        abortListener: options.signal === undefined ? undefined : abortListener,
+        settled: false,
+      };
+
+      if (options.signal !== undefined) {
+        options.signal.addEventListener("abort", abortListener, { once: true });
+      }
+
+      this.enqueueRank(request);
+    });
+  }
+
+  public dispose(): void {
+    this.worker?.terminate();
+    this.worker = undefined;
+    this.failPending(new Error("file picker worker disposed"));
+  }
+
+  private enqueueRank(request: RankRequest): void {
+    if (this.activeRank === undefined) {
+      this.sendRank(request);
+      return;
+    }
+
+    this.resolveRank(this.activeRank, []);
+    if (this.queuedRank !== undefined) {
+      this.resolveRank(this.queuedRank, []);
+    }
+    this.queuedRank = request;
+  }
+
+  private sendRank(request: RankRequest): void {
+    this.activeRank = request;
+    try {
+      this.post({
+        id: request.id,
+        type: "rank",
+        query: request.query,
+        limit: request.limit,
+      });
+    } catch (error) {
+      if (this.activeRank === request) {
+        this.activeRank = undefined;
+      }
+      this.rejectRank(request, error);
+      this.sendQueuedRank();
+    }
+  }
+
+  private sendQueuedRank(): void {
+    const request = this.queuedRank;
+    if (request === undefined || this.activeRank !== undefined) {
+      return;
+    }
+
+    this.queuedRank = undefined;
+    if (request.settled) {
+      this.sendQueuedRank();
+      return;
+    }
+
+    this.sendRank(request);
+  }
+
+  private abortRank(request: RankRequest): void {
+    if (this.queuedRank === request) {
+      this.queuedRank = undefined;
+    }
+    this.resolveRank(request, []);
+  }
+
+  private resolveRank(
+    request: RankRequest,
+    items: readonly AutocompleteItem[] | undefined
+  ): void {
+    if (request.settled) {
+      return;
+    }
+
+    request.settled = true;
+    this.removeAbortListener(request);
+    request.resolve(items);
+  }
+
+  private rejectRank(request: RankRequest, error: unknown): void {
+    if (request.settled) {
+      return;
+    }
+
+    request.settled = true;
+    this.removeAbortListener(request);
+    request.reject(error);
+  }
+
+  private sendRefreshRelative(): Promise<void> {
+    const id = this.nextRequestId++;
+    return new Promise((resolve) => {
+      this.pendingRefreshes.set(id, { resolve });
+      try {
+        this.post({
+          id,
+          type: "refreshRelative",
+          root: this.root,
+        });
+      } catch {
+        this.pendingRefreshes.delete(id);
+        resolve();
+      }
+    });
+  }
+
+  private post(message: FilePickerWorkerRequest): void {
+    this.currentWorker().postMessage(message);
+  }
+
+  private currentWorker(): Worker {
+    if (this.worker !== undefined) {
+      return this.worker;
+    }
+
+    const worker = new Worker(
+      new URL("./filePickerWorker.ts", import.meta.url),
+      {
+        type: "module",
+      }
+    );
+    worker.onmessage = (
+      event: MessageEvent<FilePickerWorkerResponse>
+    ): void => {
+      this.handleMessage(event.data);
+    };
+    worker.onerror = (event): void => {
+      this.worker = undefined;
+      worker.terminate();
+      this.failPending(new Error(event.message));
+    };
+    this.worker = worker;
+    return worker;
+  }
+
+  private handleMessage(message: FilePickerWorkerResponse): void {
+    switch (message.type) {
+      case "refreshRelative":
+        this.handleRefreshRelativeMessage(message);
+        break;
+      case "rank":
+        this.handleRankMessage(message);
+        break;
+    }
+  }
+
+  private handleRefreshRelativeMessage(
+    message: Extract<
+      FilePickerWorkerResponse,
+      { readonly type: "refreshRelative" }
+    >
+  ): void {
+    const pending = this.pendingRefreshes.get(message.id);
+    if (pending === undefined) {
+      return;
+    }
+
+    this.pendingRefreshes.delete(message.id);
+    pending.resolve();
+  }
+
+  private handleRankMessage(
+    message: Extract<FilePickerWorkerResponse, { readonly type: "rank" }>
+  ): void {
+    const request = this.activeRank;
+    if (request === undefined || request.id !== message.id) {
+      return;
+    }
+
+    this.activeRank = undefined;
+    if (message.ok) {
+      this.resolveRank(request, message.items);
+    } else {
+      this.rejectRank(request, new Error(message.error));
+    }
+    this.sendQueuedRank();
+  }
+
+  private failPending(error: unknown): void {
+    for (const [id, pending] of this.pendingRefreshes) {
+      this.pendingRefreshes.delete(id);
+      pending.resolve();
+    }
+
+    if (this.activeRank !== undefined) {
+      this.rejectRank(this.activeRank, error);
+      this.activeRank = undefined;
+    }
+    if (this.queuedRank !== undefined) {
+      this.rejectRank(this.queuedRank, error);
+      this.queuedRank = undefined;
+    }
+  }
+
+  private removeAbortListener(request: RankRequest): void {
+    if (request.signal !== undefined && request.abortListener !== undefined) {
+      request.signal.removeEventListener("abort", request.abortListener);
+    }
+  }
+}

package/src/extensions/file-picker/catalog.ts

@@ -1,6 +1,6 @@
 import { readdir, stat } from "node:fs/promises";
-import { isAbsolute, join, parse, relative, resolve, sep } from "node:path";
-import { GitignoreFilter } from "../../shared/GitignoreFilter";
+import { isAbsolute, join, parse, resolve, sep } from "node:path";
+import { FileEnumerator } from "../../shared/FileEnumerator";
 import { Paths } from "../../shared/Paths";
 
 export type FileCandidate = {
@@ -27,7 +27,6 @@ export type GitSpawner = (
 
 export type LoadRelativeOptions = {
   readonly root: string;
-  readonly limit?: number;
   readonly gitSpawner?: GitSpawner;
 };
 
@@ -35,8 +34,6 @@ export type LoadAbsoluteOptions = {
   readonly query: string;
 };
 
-const DEFAULT_LIMIT = 10_000;
-
 const defaultGitSpawner: GitSpawner = async (args, options) => {
   try {
     const child = Bun.spawn(["git", ...args], {
@@ -126,16 +123,15 @@ async function runLoadRelative(
   root: string,
   options: LoadRelativeOptions
 ): Promise<readonly FileCandidate[]> {
-  const limit = options.limit ?? DEFAULT_LIMIT;
   const spawner = options.gitSpawner ?? defaultGitSpawner;
 
   const fastPath = await tryGitListFiles(root, spawner);
   if (fastPath !== undefined) {
-    return finalizeRelative(fastPath, limit);
+    return finalizeRelative(fastPath);
   }
 
   const fallback = await scanWithGlob(root);
-  return finalizeRelative(fallback, limit);
+  return finalizeRelative(fallback);
 }
 
 async function tryGitListFiles(
@@ -155,39 +151,48 @@ async function tryGitListFiles(
 }
 
 async function scanWithGlob(root: string): Promise<readonly string[]> {
-  const filter = await GitignoreFilter.for(root);
-  const glob = new Bun.Glob("**/*");
-  const matches: string[] = [];
-
-  for await (const absolutePath of glob.scan({
-    cwd: root,
-    absolute: true,
-    onlyFiles: true,
-    dot: false,
-  })) {
-    if (!filter.ignores(absolutePath)) {
-      matches.push(Paths.toForwardSlashes(relative(root, absolutePath)));
+  // FileEnumerator already returns ignore-respecting, root-relative POSIX file
+  // paths; directories are recovered from prefixes in finalizeRelative.
+  return FileEnumerator.enumerate(root, {
+    includeDotfiles: false,
+    includeIgnored: false,
+  });
+}
+
+function finalizeRelative(paths: readonly string[]): readonly FileCandidate[] {
+  const normalized = paths.map(Paths.toForwardSlashes);
+
+  // git ls-files only emits files; recover directories from their prefixes.
+  const directories = new Set<string>();
+  for (const path of normalized) {
+    for (
+      let slash = path.indexOf("/");
+      slash !== -1;
+      slash = path.indexOf("/", slash + 1)
+    ) {
+      directories.add(path.slice(0, slash));
     }
   }
 
-  return matches;
-}
+  const candidates = [
+    ...[...directories].map((path) => toRelativeCandidate(path, true)),
+    ...normalized.map((path) => toRelativeCandidate(path, false)),
+  ];
+  candidates.sort((a, b) => a.insertPath.localeCompare(b.insertPath));
 
-function finalizeRelative(
-  paths: readonly string[],
-  limit: number
-): readonly FileCandidate[] {
-  const normalized = paths.map(Paths.toForwardSlashes);
-  normalized.sort((a, b) => a.localeCompare(b));
+  return candidates;
+}
 
-  const truncated =
-    normalized.length > limit ? normalized.slice(0, limit) : normalized;
-  return truncated.map((path) => ({
+function toRelativeCandidate(
+  path: string,
+  isDirectory: boolean
+): FileCandidate {
+  return {
     insertPath: path,
     displayPath: path,
     matchHaystack: path,
-    isDirectory: false,
-  }));
+    isDirectory,
+  };
 }
 
 async function findAnchor(absolutePath: string): Promise<string> {

package/src/extensions/file-picker/filePickerWorker.ts

@@ -0,0 +1,72 @@
+import type { FileCandidate } from "./catalog";
+import { loadRelative } from "./catalog";
+import type {
+  FilePickerWorkerRequest,
+  FilePickerWorkerResponse,
+} from "./filePickerWorkerMessages";
+import { rank } from "./ranker";
+
+let cachedRelative: readonly FileCandidate[] | undefined;
+
+const toErrorMessage = (error: unknown): string => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+};
+
+const refreshRelative = async (id: number, root: string): Promise<void> => {
+  try {
+    cachedRelative = await loadRelative({ root });
+    self.postMessage({
+      id,
+      type: "refreshRelative",
+      ok: true,
+    } satisfies FilePickerWorkerResponse);
+  } catch (error) {
+    if (cachedRelative === undefined) {
+      cachedRelative = [];
+    }
+    self.postMessage({
+      id,
+      type: "refreshRelative",
+      ok: false,
+      error: toErrorMessage(error),
+    } satisfies FilePickerWorkerResponse);
+  }
+};
+
+const rankSuggestions = async (
+  id: number,
+  query: string,
+  limit: number | undefined
+): Promise<void> => {
+  try {
+    const items = await rank(query, { cachedRelative, limit });
+    self.postMessage({
+      id,
+      type: "rank",
+      ok: true,
+      items,
+    } satisfies FilePickerWorkerResponse);
+  } catch (error) {
+    self.postMessage({
+      id,
+      type: "rank",
+      ok: false,
+      error: toErrorMessage(error),
+    } satisfies FilePickerWorkerResponse);
+  }
+};
+
+self.onmessage = (event: MessageEvent<FilePickerWorkerRequest>): void => {
+  const message = event.data;
+  switch (message.type) {
+    case "refreshRelative":
+      void refreshRelative(message.id, message.root);
+      break;
+    case "rank":
+      void rankSuggestions(message.id, message.query, message.limit);
+      break;
+  }
+};