@ramarivera/pi-television 0.0.2 → 0.0.4

package/README.md

@@ -1,11 +1,55 @@
 # @ramarivera/pi-television
 
-Pi extension that replaces the fuzzy file finder with television (tv) for faster, non-blocking file search
+Pi extension that keeps Pi's native file picking UX while replacing the default `@file` search path with a faster background television-style search.
 
 ## Install
 
 ```sh
-pi install npm:@ramarivera/pi-television@0.0.1
+pi install npm:@ramarivera/pi-television@0.0.4
+```
+
+## Modes
+
+### Default: native live picker
+
+By default, typing `@` in Pi keeps using Pi's native picker UI, but the suggestions come from this extension's background file search instead of launching the full-screen `tv` interface.
+
+### Optional: select dialog mode
+
+If you want the simpler fallback flow, create `.pi/television.json` in your project:
+
+```json
+{
+  "mode": "select-dialog"
+}
+```
+
+That mode uses background search plus a native Pi select dialog when you trigger `@`.
+
+## Config
+
+Project config lives at:
+
+```text
+.pi/television.json
+```
+
+You can also set a user-level default at:
+
+```text
+~/.pi/agent/television.json
+```
+
+Project config overrides user config.
+
+Supported fields:
+
+```json
+{
+  "mode": "native-live",
+  "maxResults": 20,
+  "refreshMs": 10000
+}
 ```
 
 ## Local Development
@@ -37,4 +81,3 @@ Before the first publish, configure npm trusted publishing:
 - environment: blank unless the workflow is changed to require one
 
 No `NPM_TOKEN` is required for trusted publishing.
-

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ramarivera/pi-television",
-  "version": "0.0.2",
-  "description": "Pi extension that replaces the fuzzy file finder with television (tv) for faster, non-blocking file search",
+  "version": "0.0.4",
+  "description": "Pi extension that powers native Pi @file picking with background television-style search",
   "type": "module",
   "license": "MIT",
   "author": "Ramiro Rivera",

package/src/extension.ts

@@ -1,11 +1,21 @@
-import { spawn } from "node:child_process";
-import { relative, resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, relative, resolve } from "node:path";
 import type {
   ExtensionAPI,
   ExtensionContext,
   TerminalInputHandler,
 } from "@earendil-works/pi-coding-agent";
-import { decodeKittyPrintable, Key, matchesKey } from "@earendil-works/pi-tui";
+import type {
+  AutocompleteItem,
+  AutocompleteProvider,
+} from "@earendil-works/pi-tui";
+import {
+  decodeKittyPrintable,
+  fuzzyFilter,
+  Key,
+  matchesKey,
+} from "@earendil-works/pi-tui";
 
 export type ExtensionInfo = {
   name: string;
@@ -17,121 +27,296 @@ export type TelevisionPickResult =
   | { status: "cancelled" }
   | { status: "failed"; message: string };
 
-export type TelevisionRunnerOptions = {
+export type TelevisionMode = "native-live" | "select-dialog";
+
+export type TelevisionConfig = {
+  mode?: TelevisionMode;
+  maxResults?: number;
+  refreshMs?: number;
+};
+
+export type TelevisionResolvedConfig = {
+  mode: TelevisionMode;
+  maxResults: number;
+  refreshMs: number;
+};
+
+export type TelevisionSearchResult = {
+  path: string;
+  label?: string;
+  description?: string;
+};
+
+export type TelevisionSearchOptions = {
   cwd: string;
   query?: string;
   signal?: AbortSignal;
+  maxResults?: number;
+  refreshMs?: number;
 };
 
-export type TelevisionRunner = (
-  options: TelevisionRunnerOptions,
-) => Promise<TelevisionPickResult>;
+export type TelevisionSearcher = (
+  options: TelevisionSearchOptions,
+) => Promise<TelevisionSearchResult[]>;
+
+export type TelevisionConfigLoader = (
+  cwd: string,
+) => Promise<TelevisionResolvedConfig>;
 
 export type TelevisionExtensionOptions = {
   commandName?: string;
   shortcut?: string;
-  runner?: TelevisionRunner;
+  searcher?: TelevisionSearcher;
+  configLoader?: TelevisionConfigLoader;
 };
 
 const STATUS_KEY = "pi-television";
 const DEFAULT_COMMAND_NAME = "television";
 const DEFAULT_SHORTCUT = "@";
+const DEFAULT_MAX_RESULTS = 20;
+const DEFAULT_REFRESH_MS = 10_000;
 
 export const extensionInfo: ExtensionInfo = {
   name: "television",
   description:
-    "Pi extension that replaces the fuzzy file finder with television (tv) for faster, non-blocking file search",
+    "Pi extension that powers native @file picking with background television-style search",
+};
+
+const defaultResolvedConfig: TelevisionResolvedConfig = {
+  mode: "native-live",
+  maxResults: DEFAULT_MAX_RESULTS,
+  refreshMs: DEFAULT_REFRESH_MS,
 };
 
-function cleanSelectedPath(stdout: string): string | null {
-  const selected = stdout
+type FileIndexCache = {
+  loadedAt: number;
+  entries?: string[];
+  pending?: Promise<string[]>;
+};
+
+function uniq(values: string[]): string[] {
+  const seen = new Set<string>();
+  const deduped: string[] = [];
+
+  for (const value of values) {
+    if (seen.has(value)) continue;
+    seen.add(value);
+    deduped.push(value);
+  }
+
+  return deduped;
+}
+
+function cleanPaths(stdout: string): string[] {
+  return stdout
     .split(/\r?\n/)
     .map((line) => line.trim())
-    .find((line) => line.length > 0);
-  return selected ?? null;
-}
-
-function buildTvArgs(query: string | undefined): string[] {
-  const sourceCommand =
-    "fd --type f --type d --hidden --follow --exclude .git --strip-cwd-prefix";
-  const args = [
-    "--source-command",
-    sourceCommand,
-    "--source-display",
-    "{}",
-    "--source-output",
-    "{}",
-    "--preview-command",
-    "test -d {} && ls -la {} || sed -n '1,160p' {}",
-    "--preview-header",
-    "{}",
-  ];
-
-  if (query?.trim()) {
-    args.push("--input", query.trim());
+    .filter((line) => line.length > 0);
+}
+
+function extractFileToken(textBeforeCursor: string): string | undefined {
+  const match = textBeforeCursor.match(/(?:^|[ \t])@([^\s@]*)$/);
+  return match?.[1];
+}
+
+function toAutocompleteItem(result: TelevisionSearchResult): AutocompleteItem {
+  return {
+    value: `@${result.path}`,
+    label: result.label ?? result.path,
+    description: result.description ?? result.path,
+  };
+}
+
+function normalizeTelevisionConfig(
+  config: TelevisionConfig | undefined,
+): TelevisionResolvedConfig {
+  return {
+    mode: config?.mode ?? defaultResolvedConfig.mode,
+    maxResults: config?.maxResults ?? defaultResolvedConfig.maxResults,
+    refreshMs: config?.refreshMs ?? defaultResolvedConfig.refreshMs,
+  };
+}
+
+async function loadConfigFile(
+  path: string,
+): Promise<TelevisionConfig | undefined> {
+  try {
+    const content = await readFile(path, "utf8");
+    const parsed = JSON.parse(content) as TelevisionConfig;
+    return parsed;
+  } catch (error) {
+    const nodeError = error as NodeJS.ErrnoException;
+    if (nodeError.code === "ENOENT") {
+      return undefined;
+    }
+    throw new Error(`television: failed to read ${path}: ${nodeError.message}`);
   }
+}
+
+export async function loadTelevisionConfig(
+  cwd: string,
+): Promise<TelevisionResolvedConfig> {
+  const globalConfig = await loadConfigFile(
+    resolve(homedir(), ".pi", "agent", "television.json"),
+  );
+  const projectConfig = await loadConfigFile(
+    resolve(cwd, ".pi", "television.json"),
+  );
 
-  return args;
+  return normalizeTelevisionConfig({
+    ...globalConfig,
+    ...projectConfig,
+  });
 }
 
-export function runTelevision(
-  options: TelevisionRunnerOptions,
-): Promise<TelevisionPickResult> {
-  return new Promise((resolvePick) => {
-    if (options.signal?.aborted) {
-      resolvePick({ status: "cancelled" });
-      return;
+export function rankTelevisionResults(
+  paths: string[],
+  query: string | undefined,
+  maxResults: number,
+): TelevisionSearchResult[] {
+  const trimmedQuery = query?.trim() ?? "";
+  const limitedMaxResults = Math.max(1, maxResults);
+
+  if (!trimmedQuery) {
+    return paths.slice(0, limitedMaxResults).map((path) => ({ path }));
+  }
+
+  const exactPrefixMatches = paths.filter((path) =>
+    path.startsWith(trimmedQuery),
+  );
+  const basenamePrefixMatches = paths.filter(
+    (path) =>
+      basename(path).startsWith(trimmedQuery) &&
+      !exactPrefixMatches.includes(path),
+  );
+  const fuzzyMatches = fuzzyFilter(paths, trimmedQuery, (path) => {
+    const name = basename(path);
+    return name === path ? path : `${name} ${path}`;
+  });
+
+  return uniq([
+    ...exactPrefixMatches,
+    ...basenamePrefixMatches,
+    ...fuzzyMatches,
+  ])
+    .slice(0, limitedMaxResults)
+    .map((path) => ({ path }));
+}
+
+export function createDefaultSearcher(pi: ExtensionAPI): TelevisionSearcher {
+  const cache = new Map<string, FileIndexCache>();
+
+  return async ({
+    cwd,
+    query,
+    signal,
+    maxResults = DEFAULT_MAX_RESULTS,
+    refreshMs = DEFAULT_REFRESH_MS,
+  }) => {
+    const now = Date.now();
+    const cached = cache.get(cwd);
+
+    if (cached?.entries && now - cached.loadedAt < refreshMs) {
+      return rankTelevisionResults(cached.entries, query, maxResults);
     }
 
-    const child = spawn("tv", buildTvArgs(options.query), {
-      cwd: options.cwd,
-      stdio: ["inherit", "pipe", "inherit"],
-    });
+    if (cached?.pending) {
+      const entries = await cached.pending;
+      return rankTelevisionResults(entries, query, maxResults);
+    }
 
-    let stdout = "";
-    let settled = false;
-
-    const settle = (result: TelevisionPickResult) => {
-      if (settled) return;
-      settled = true;
-      options.signal?.removeEventListener("abort", onAbort);
-      resolvePick(result);
-    };
-
-    const onAbort = () => {
-      child.kill("SIGTERM");
-      settle({ status: "cancelled" });
-    };
-
-    options.signal?.addEventListener("abort", onAbort, { once: true });
-    child.stdout?.setEncoding("utf8");
-    child.stdout?.on("data", (chunk: string) => {
-      stdout += chunk;
-    });
-    child.on("error", (error) => {
-      settle({ status: "failed", message: error.message });
-    });
-    child.on("close", (code, signal) => {
-      if (settled) return;
-      if (signal) {
-        settle({ status: "cancelled" });
-        return;
-      }
-      if (code === 0) {
-        const path = cleanSelectedPath(stdout);
-        settle(path ? { status: "selected", path } : { status: "cancelled" });
-        return;
+    const pending = (async () => {
+      const result = await pi.exec(
+        "fd",
+        [
+          "--type",
+          "f",
+          "--hidden",
+          "--follow",
+          "--exclude",
+          ".git",
+          "--strip-cwd-prefix",
+        ],
+        {
+          cwd,
+          signal,
+          timeout: 10_000,
+        },
+      );
+
+      if (result.code !== 0) {
+        const details = result.stderr.trim() || `exit code ${result.code}`;
+        throw new Error(`television: fd failed: ${details}`);
       }
-      if (code === 130 || code === 1) {
-        settle({ status: "cancelled" });
-        return;
+
+      const entries = cleanPaths(result.stdout);
+      cache.set(cwd, { loadedAt: Date.now(), entries });
+      return entries;
+    })();
+
+    cache.set(cwd, { loadedAt: now, pending });
+
+    try {
+      const entries = await pending;
+      return rankTelevisionResults(entries, query, maxResults);
+    } catch (error) {
+      cache.delete(cwd);
+      throw error;
+    }
+  };
+}
+
+export function createTelevisionAutocompleteProvider(
+  current: AutocompleteProvider,
+  searcher: TelevisionSearcher,
+  cwd: string,
+  config: TelevisionResolvedConfig,
+): AutocompleteProvider {
+  return {
+    async getSuggestions(lines, cursorLine, cursorCol, options) {
+      const line = lines[cursorLine] ?? "";
+      const textBeforeCursor = line.slice(0, cursorCol);
+      const token = extractFileToken(textBeforeCursor);
+
+      if (token === undefined) {
+        return current.getSuggestions(lines, cursorLine, cursorCol, options);
       }
-      settle({
-        status: "failed",
-        message: `television exited with code ${code ?? "unknown"}`,
+
+      const results = await searcher({
+        cwd,
+        query: token,
+        signal: options.signal,
+        maxResults: config.maxResults,
+        refreshMs: config.refreshMs,
       });
-    });
-  });
+
+      if (options.signal.aborted || results.length === 0) {
+        return current.getSuggestions(lines, cursorLine, cursorCol, options);
+      }
+
+      return {
+        prefix: `@${token}`,
+        items: results.slice(0, config.maxResults).map(toAutocompleteItem),
+      };
+    },
+
+    applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+      return current.applyCompletion(
+        lines,
+        cursorLine,
+        cursorCol,
+        item,
+        prefix,
+      );
+    },
+
+    shouldTriggerFileCompletion(lines, cursorLine, cursorCol) {
+      return (
+        current.shouldTriggerFileCompletion?.(lines, cursorLine, cursorCol) ??
+        true
+      );
+    },
+  };
 }
 
 export function toEditorAttachmentPath(
@@ -161,17 +346,24 @@ function isBoundaryKey(data: string): boolean {
   );
 }
 
-async function pickFile(
+async function findFiles(
   ctx: ExtensionContext,
-  runner: TelevisionRunner,
+  searcher: TelevisionSearcher,
   query: string | undefined,
-): Promise<TelevisionPickResult> {
-  ctx.ui.setStatus(STATUS_KEY, "television: picking file");
-  ctx.ui.setWorkingMessage("television is picking a file");
+  config: TelevisionResolvedConfig,
+): Promise<TelevisionSearchResult[]> {
+  ctx.ui.setStatus(STATUS_KEY, "television: finding files");
+  ctx.ui.setWorkingMessage("television is finding files");
   ctx.ui.setWorkingIndicator({ frames: ["tv"], intervalMs: 1000 });
 
   try {
-    return await runner({ cwd: ctx.cwd, query, signal: ctx.signal });
+    return await searcher({
+      cwd: ctx.cwd,
+      query,
+      signal: ctx.signal,
+      maxResults: config.maxResults,
+      refreshMs: config.refreshMs,
+    });
   } finally {
     ctx.ui.setStatus(STATUS_KEY, undefined);
     ctx.ui.setWorkingMessage();
@@ -179,26 +371,43 @@ async function pickFile(
   }
 }
 
-async function pastePickedFile(
+async function pickFileWithSelectDialog(
   ctx: ExtensionContext,
-  runner: TelevisionRunner,
+  searcher: TelevisionSearcher,
   query: string | undefined,
+  config: TelevisionResolvedConfig,
 ): Promise<TelevisionPickResult> {
-  const result = await pickFile(ctx, runner, query);
+  try {
+    const results = await findFiles(ctx, searcher, query, config);
 
-  if (result.status === "selected") {
-    ctx.ui.pasteToEditor(toEditorAttachmentPath(result.path, ctx.cwd));
-  } else if (result.status === "failed") {
-    ctx.ui.notify(`television failed: ${result.message}`, "error");
-  }
+    if (results.length === 0) {
+      ctx.ui.notify("television: no matching files found", "warning");
+      return { status: "cancelled" };
+    }
+
+    const choice = await ctx.ui.select(
+      "television",
+      results.slice(0, config.maxResults).map((result) => result.path),
+    );
 
-  return result;
+    if (!choice) {
+      return { status: "cancelled" };
+    }
+
+    ctx.ui.pasteToEditor(toEditorAttachmentPath(choice, ctx.cwd));
+    return { status: "selected", path: choice };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    ctx.ui.notify(message, "error");
+    return { status: "failed", message };
+  }
 }
 
 function installShortcut(
   ctx: ExtensionContext,
-  runner: TelevisionRunner,
+  searcher: TelevisionSearcher,
   shortcut: string,
+  config: TelevisionResolvedConfig,
 ): void {
   let pickerOpen = false;
   let lastKeyWasBoundary = true;
@@ -218,7 +427,12 @@ function installShortcut(
     }
 
     pickerOpen = true;
-    void pastePickedFile(ctx, runner, query).finally(() => {
+    void pickFileWithSelectDialog(
+      ctx,
+      searcher,
+      query || undefined,
+      config,
+    ).finally(() => {
       pickerOpen = false;
       lastKeyWasBoundary = true;
     });
@@ -232,20 +446,49 @@ function installShortcut(
 export function createExtension(options: TelevisionExtensionOptions = {}) {
   const commandName = options.commandName ?? DEFAULT_COMMAND_NAME;
   const shortcut = options.shortcut ?? DEFAULT_SHORTCUT;
-  const runner = options.runner ?? runTelevision;
 
   return {
     name: extensionInfo.name,
     register(pi: ExtensionAPI): void {
-      pi.on("session_start", (_event, ctx) => {
-        installShortcut(ctx, runner, shortcut);
+      const searcher = options.searcher ?? createDefaultSearcher(pi);
+      const configLoader = options.configLoader ?? loadTelevisionConfig;
+      let config = defaultResolvedConfig;
+
+      pi.on("session_start", async (_event, ctx) => {
+        try {
+          config = await configLoader(ctx.cwd);
+        } catch (error) {
+          const message =
+            error instanceof Error ? error.message : String(error);
+          config = defaultResolvedConfig;
+          ctx.ui.notify(message, "error");
+        }
+
+        if (config.mode === "native-live") {
+          ctx.ui.addAutocompleteProvider((current) =>
+            createTelevisionAutocompleteProvider(
+              current,
+              searcher,
+              ctx.cwd,
+              config,
+            ),
+          );
+          return;
+        }
+
+        installShortcut(ctx, searcher, shortcut, config);
       });
 
       pi.registerCommand(commandName, {
         description:
-          "Pick a file with television (tv) and insert it as an @file attachment",
+          "Find a file in the background and insert it as an @file attachment",
         handler: async (args, ctx) => {
-          await pastePickedFile(ctx, runner, args.trim());
+          await pickFileWithSelectDialog(
+            ctx,
+            searcher,
+            args.trim() || undefined,
+            config,
+          );
         },
       });
     },

package/src/index.ts

@@ -2,14 +2,23 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { createExtension } from "./extension.ts";
 
 export type {
+  TelevisionConfig,
+  TelevisionConfigLoader,
   TelevisionExtensionOptions,
+  TelevisionMode,
   TelevisionPickResult,
-  TelevisionRunner,
-  TelevisionRunnerOptions,
+  TelevisionResolvedConfig,
+  TelevisionSearcher,
+  TelevisionSearchOptions,
+  TelevisionSearchResult,
 } from "./extension.ts";
 export {
+  createDefaultSearcher,
   createExtension,
+  createTelevisionAutocompleteProvider,
   extensionInfo,
+  loadTelevisionConfig,
+  rankTelevisionResults,
   toEditorAttachmentPath,
 } from "./extension.ts";