@firstpick/pi-utils 0.1.7 → 0.1.8

package/index.ts

@@ -3,6 +3,7 @@ export * from "./src/env";
 export * from "./src/text";
 export * from "./src/tokens";
 export * from "./src/prompt-calibration";
+export * from "./src/prompt-export-estimate";
 export * from "./src/async";
 export * from "./src/ui/working-indicator";
 export * from "./src/local-wiki";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@firstpick/pi-utils",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Shared utilities for Firstpick Pi extension packages.",
   "main": "index.ts",
   "exports": {
@@ -10,6 +10,7 @@
     "./text": "./src/text.ts",
     "./tokens": "./src/tokens.ts",
     "./prompt-calibration": "./src/prompt-calibration.ts",
+    "./prompt-export-estimate": "./src/prompt-export-estimate.ts",
     "./async": "./src/async.ts",
     "./ui": "./src/ui/working-indicator.ts",
     "./local-wiki": "./src/local-wiki.ts"

package/src/prompt-export-estimate.ts

@@ -0,0 +1,198 @@
+import * as fs from "node:fs";
+import { createRequire } from "node:module";
+import * as os from "node:os";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { InitialPromptCalibration, InitialPromptInputEstimate, InitialPromptToolInfo } from "./tokens";
+import { estimateInitialPromptInput } from "./tokens";
+
+export type ExportBackedInitialPromptEstimate = {
+  estimate: InitialPromptInputEstimate;
+  systemPrompt: string;
+  /** Active tool schemas used for the estimate, preferably decoded from the temporary export HTML. */
+  tools: InitialPromptToolInfo[];
+  source: "export-html" | "direct";
+  warning?: string;
+};
+
+type ExportSessionData = {
+  systemPrompt?: unknown;
+  tools?: unknown;
+};
+
+type ExportSessionToHtml = (
+  sm: ExtensionContext["sessionManager"],
+  state?: { systemPrompt?: string; tools?: InitialPromptToolInfo[] },
+  options?: { outputPath?: string; themeName?: string } | string,
+) => Promise<string>;
+
+type PromptEstimatePiApi = Pick<ExtensionAPI, "getActiveTools" | "getAllTools">;
+type PromptEstimateContext = Pick<ExtensionContext, "getSystemPrompt" | "sessionManager">;
+
+let exportSessionToHtmlPromise: Promise<ExportSessionToHtml | null> | null = null;
+
+function resolvePiExportHtmlModuleUrl(): string | null {
+  try {
+    const basePath = typeof __filename === "string" && path.isAbsolute(__filename) ? __filename : path.join(process.cwd(), "package.json");
+    const requireFromHere = createRequire(basePath);
+    const candidateDirs = requireFromHere.resolve.paths("@earendil-works/pi-coding-agent") ?? [];
+    for (const dir of candidateDirs) {
+      const candidate = path.join(dir, "@earendil-works", "pi-coding-agent", "dist", "core", "export-html", "index.js");
+      if (fs.existsSync(candidate)) return pathToFileURL(candidate).href;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function loadPiExportSessionToHtml(): Promise<ExportSessionToHtml | null> {
+  exportSessionToHtmlPromise ??= (async () => {
+    try {
+      const exportModuleUrl = resolvePiExportHtmlModuleUrl();
+      if (!exportModuleUrl) return null;
+      const mod = (await import(exportModuleUrl)) as { exportSessionToHtml?: unknown };
+      return typeof mod.exportSessionToHtml === "function" ? (mod.exportSessionToHtml as ExportSessionToHtml) : null;
+    } catch {
+      return null;
+    }
+  })();
+  return exportSessionToHtmlPromise;
+}
+
+function makeTempExportPath(sessionId: string | undefined): string {
+  const safeSessionId = (sessionId || "session").replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 80);
+  const nonce = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  return path.join(os.tmpdir(), `pi-prompt-estimate-export-${safeSessionId}-${nonce}.html`);
+}
+
+function decodeSessionDataFromExportHtml(html: string): ExportSessionData | null {
+  const match = html.match(/<script[^>]*id=["']session-data["'][^>]*>([^<]*)<\/script>/i);
+  const encoded = match?.[1]?.trim();
+  if (!encoded) return null;
+
+  try {
+    const parsed = JSON.parse(Buffer.from(encoded, "base64").toString("utf8"));
+    return parsed && typeof parsed === "object" ? (parsed as ExportSessionData) : null;
+  } catch {
+    return null;
+  }
+}
+
+function normalizeExportedTools(tools: unknown): InitialPromptToolInfo[] {
+  if (!Array.isArray(tools)) return [];
+
+  const seen = new Set<string>();
+  const normalized: InitialPromptToolInfo[] = [];
+  for (const tool of tools) {
+    const record = (tool && typeof tool === "object" ? tool : {}) as Record<string, unknown>;
+    const name = typeof record.name === "string" ? record.name : "";
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    normalized.push({
+      name,
+      description: typeof record.description === "string" ? record.description : undefined,
+      parameters: record.parameters,
+    });
+  }
+  return normalized;
+}
+
+export function getActiveInitialPromptToolInfos(pi: PromptEstimatePiApi): InitialPromptToolInfo[] {
+  let activeTools: string[] = [];
+  let allTools: InitialPromptToolInfo[] = [];
+
+  try {
+    activeTools = pi.getActiveTools();
+  } catch {
+    activeTools = [];
+  }
+
+  try {
+    allTools = pi.getAllTools().map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters,
+    }));
+  } catch {
+    allTools = [];
+  }
+
+  if (allTools.length === 0) return [];
+
+  const toolsByName = new Map<string, InitialPromptToolInfo>();
+  for (const tool of allTools) {
+    if (tool.name && !toolsByName.has(tool.name)) toolsByName.set(tool.name, tool);
+  }
+
+  const orderedNames = activeTools.length > 0 ? activeTools : Array.from(toolsByName.keys()).sort();
+  return orderedNames.map((name) => toolsByName.get(name)).filter((tool): tool is InitialPromptToolInfo => !!tool);
+}
+
+export function estimateInitialPromptForPiContext(
+  pi: PromptEstimatePiApi,
+  systemPrompt: string,
+  calibration?: InitialPromptCalibration | null,
+  exportedTools?: InitialPromptToolInfo[],
+): InitialPromptInputEstimate {
+  const tools = exportedTools ?? getActiveInitialPromptToolInfos(pi);
+  return estimateInitialPromptInput({
+    systemPrompt,
+    activeTools: tools.map((tool) => tool.name),
+    allTools: tools,
+    calibration,
+  });
+}
+
+export async function estimateInitialPromptFromPiExport(
+  pi: PromptEstimatePiApi,
+  ctx: PromptEstimateContext,
+  calibration?: InitialPromptCalibration | null,
+): Promise<ExportBackedInitialPromptEstimate> {
+  const fallbackSystemPrompt = ctx.getSystemPrompt();
+  const fallbackTools = getActiveInitialPromptToolInfos(pi);
+  const exportSessionToHtml = await loadPiExportSessionToHtml();
+  if (!exportSessionToHtml) {
+    return {
+      estimate: estimateInitialPromptForPiContext(pi, fallbackSystemPrompt, calibration, fallbackTools),
+      systemPrompt: fallbackSystemPrompt,
+      tools: fallbackTools,
+      source: "direct",
+      warning: "Pi HTML export API unavailable; used live context fallback.",
+    };
+  }
+
+  const outputPath = makeTempExportPath(ctx.sessionManager.getSessionId());
+  let writtenPath = outputPath;
+  try {
+    writtenPath = await exportSessionToHtml(
+      ctx.sessionManager,
+      { systemPrompt: fallbackSystemPrompt, tools: fallbackTools },
+      { outputPath },
+    );
+    const html = fs.readFileSync(writtenPath, "utf8");
+    const sessionData = decodeSessionDataFromExportHtml(html);
+    const exportedSystemPrompt = typeof sessionData?.systemPrompt === "string" ? sessionData.systemPrompt : fallbackSystemPrompt;
+    const exportedTools = normalizeExportedTools(sessionData?.tools);
+    const tools = exportedTools.length > 0 ? exportedTools : fallbackTools;
+    const estimate = estimateInitialPromptForPiContext(pi, exportedSystemPrompt, calibration, tools);
+    return { estimate, systemPrompt: exportedSystemPrompt, tools, source: "export-html" };
+  } catch (error) {
+    return {
+      estimate: estimateInitialPromptForPiContext(pi, fallbackSystemPrompt, calibration, fallbackTools),
+      systemPrompt: fallbackSystemPrompt,
+      tools: fallbackTools,
+      source: "direct",
+      warning: `Pi HTML export failed; used live context fallback (${error instanceof Error ? error.message : String(error)}).`,
+    };
+  } finally {
+    for (const filePath of new Set([outputPath, writtenPath])) {
+      try {
+        fs.rmSync(filePath, { force: true });
+      } catch {
+        // Best-effort cleanup only.
+      }
+    }
+  }
+}