ahead-pi 0.1.1 → 0.2.1

package/src/reference-viewer.ts

@@ -0,0 +1,71 @@
+import {
+  getMarkdownTheme,
+  type ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+  Markdown,
+  matchesKey,
+  truncateToWidth,
+  visibleWidth,
+} from "@earendil-works/pi-tui";
+
+export async function showReferenceViewer(
+  ctx: ExtensionCommandContext,
+  title: string,
+  content: string,
+): Promise<void> {
+  await ctx.ui.custom<void>((tui, theme, _keybindings, done) => {
+    const markdown = new Markdown(content.trim(), 0, 0, getMarkdownTheme());
+    let scrollOffset = 0;
+    let pageSize = 10;
+    let totalLines = 0;
+
+    const component = {
+      render(width: number): string[] {
+        const innerWidth = Math.max(20, width - 2);
+        const contentWidth = Math.max(18, innerWidth - 2);
+        const rendered = markdown.render(contentWidth);
+        totalLines = rendered.length;
+        pageSize = Math.max(6, Math.min(30, tui.terminal.rows - 7));
+        const maxOffset = Math.max(0, totalLines - pageSize);
+        scrollOffset = Math.min(scrollOffset, maxOffset);
+        const visible = rendered.slice(scrollOffset, scrollOffset + pageSize);
+        const remaining = Math.max(0, totalLines - pageSize - scrollOffset);
+        const border = (value: string) => theme.fg("border", value);
+        const pad = (value: string): string => {
+          const truncated = truncateToWidth(value, innerWidth, "…", true);
+          return `${truncated}${" ".repeat(Math.max(0, innerWidth - visibleWidth(truncated)))}`;
+        };
+        const lines = [
+          border(`╭${"─".repeat(innerWidth)}╮`),
+          `${border("│")}${pad(` ${theme.fg("accent", theme.bold(title))}`)}${border("│")}`,
+          `${border("│")}${pad(theme.fg("dim", ` ↑ ${scrollOffset} lines · ↓ ${remaining} lines`))}${border("│")}`,
+        ];
+        for (const line of visible) lines.push(`${border("│")}${pad(` ${line}`)}${border("│")}`);
+        for (let index = visible.length; index < pageSize; index += 1) {
+          lines.push(`${border("│")}${pad("")}${border("│")}`);
+        }
+        lines.push(
+          `${border("│")}${pad(theme.fg("dim", " ↑↓ scroll · PgUp/PgDn page · Home/End jump · Esc close"))}${border("│")}`,
+          border(`╰${"─".repeat(innerWidth)}╯`),
+        );
+        return lines;
+      },
+      invalidate(): void {
+        markdown.invalidate();
+      },
+      handleInput(data: string): void {
+        const maxOffset = Math.max(0, totalLines - pageSize);
+        if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) done();
+        else if (matchesKey(data, "up")) scrollOffset = Math.max(0, scrollOffset - 1);
+        else if (matchesKey(data, "down")) scrollOffset = Math.min(maxOffset, scrollOffset + 1);
+        else if (matchesKey(data, "pageUp")) scrollOffset = Math.max(0, scrollOffset - pageSize);
+        else if (matchesKey(data, "pageDown")) scrollOffset = Math.min(maxOffset, scrollOffset + pageSize);
+        else if (matchesKey(data, "home")) scrollOffset = 0;
+        else if (matchesKey(data, "end")) scrollOffset = maxOffset;
+        tui.requestRender();
+      },
+    };
+    return component;
+  });
+}

package/src/reference.ts

@@ -0,0 +1,56 @@
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+
+const referenceDirectory = fileURLToPath(new URL("../generated/reference/", import.meta.url));
+
+export interface ReferenceEntry {
+  id: string;
+  path: string;
+  title: string;
+  summary: string;
+  phases: string[];
+}
+
+interface ReferenceIndex {
+  generated_from: string[];
+  references: ReferenceEntry[];
+}
+
+let indexPromise: Promise<ReferenceIndex> | undefined;
+
+export async function loadReferenceIndex(): Promise<ReferenceIndex> {
+  indexPromise ??= readFile(`${referenceDirectory}index.json`, "utf8")
+    .then((content) => JSON.parse(content) as ReferenceIndex);
+  return indexPromise;
+}
+
+export async function relevantReferences(phaseId?: string): Promise<ReferenceEntry[]> {
+  const { references } = await loadReferenceIndex();
+  if (!phaseId) return references.filter((entry) => entry.phases.includes("*"));
+  return references.filter((entry) => entry.phases.includes("*") || entry.phases.includes(phaseId));
+}
+
+export async function findReference(topic: string): Promise<ReferenceEntry | undefined> {
+  const normalized = normalize(topic);
+  const { references } = await loadReferenceIndex();
+  return references.find((entry) =>
+    normalize(entry.id) === normalized
+    || normalize(entry.path) === normalized
+    || normalize(entry.title) === normalized
+  ) ?? references.find((entry) =>
+    normalize(entry.id).includes(normalized)
+    || normalize(entry.path).includes(normalized)
+    || normalize(entry.title).includes(normalized)
+  );
+}
+
+export async function readReference(entry: ReferenceEntry): Promise<string> {
+  if (entry.path.includes("..") || entry.path.startsWith("/")) {
+    throw new Error(`Invalid packaged AHEAD reference path: ${entry.path}`);
+  }
+  return readFile(`${referenceDirectory}${entry.path}`, "utf8");
+}
+
+function normalize(value: string): string {
+  return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}