@pi-unipi/web-api 0.1.14 → 0.1.16

package/src/tui/result.ts

@@ -0,0 +1,173 @@
+/**
+ * @unipi/web-api — TUI Result Renderer
+ *
+ * Renders single and batch results for TUI display.
+ */
+
+import type { FetchResult, BatchFetchResult, FetchError } from "../engine/types.js";
+
+/** Maximum preview lines */
+const PREVIEW_LINES = 7;
+
+/**
+ * Truncate content for preview.
+ *
+ * @param content - Content to preview
+ * @param maxLines - Maximum lines
+ * @returns Preview string
+ */
+function truncatePreview(content: string, maxLines: number = PREVIEW_LINES): string {
+  const lines = content.split("\n").slice(0, maxLines);
+  return lines.join("\n");
+}
+
+/**
+ * Render a single result for display.
+ *
+ * @param result - Fetch result
+ * @param verbose - Include metadata header
+ * @returns Formatted string
+ */
+export function renderSingleResult(
+  result: FetchResult,
+  verbose: boolean = true
+): string {
+  const lines: string[] = [];
+
+  if (verbose) {
+    // Title
+    lines.push(`# ${result.title || "Untitled"}`);
+    lines.push("");
+
+    // Metadata
+    const meta: string[] = [];
+    if (result.author) {
+      meta.push(`Author: ${result.author}`);
+    }
+    if (result.published) {
+      meta.push(`Published: ${result.published}`);
+    }
+    if (result.site) {
+      meta.push(`Site: ${result.site}`);
+    }
+    if (result.language) {
+      meta.push(`Language: ${result.language}`);
+    }
+    if (result.wordCount) {
+      meta.push(`Words: ${result.wordCount}`);
+    }
+
+    if (meta.length > 0) {
+      lines.push(meta.join(" · "));
+    }
+
+    // URL
+    lines.push(`URL: ${result.url}`);
+    if (result.finalUrl !== result.url) {
+      lines.push(`Final URL: ${result.finalUrl}`);
+    }
+
+    lines.push("");
+    lines.push("---");
+    lines.push("");
+  }
+
+  // Content preview
+  const preview = truncatePreview(result.content);
+  lines.push(preview);
+
+  // Expand hint
+  if (result.content.split("\n").length > PREVIEW_LINES) {
+    lines.push("");
+    lines.push(`... [${result.wordCount} words total · Ctrl+O to expand]`);
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Render a batch result for display.
+ *
+ * @param result - Batch fetch result
+ * @returns Formatted string
+ */
+export function renderBatchResult(result: BatchFetchResult): string {
+  const lines: string[] = [];
+
+  // Summary header
+  lines.push(`# Batch Read Results`);
+  lines.push("");
+  lines.push(
+    `Total: ${result.total} · Succeeded: ${result.succeeded} · Failed: ${result.failed}`
+  );
+  lines.push("");
+
+  // Per-item results
+  for (let i = 0; i < result.items.length; i++) {
+    const item = result.items[i];
+    const status = item.status === "done" ? "✓" : "✗";
+
+    lines.push(`## [${i + 1}/${result.total}] ${status}`);
+
+    if (item.status === "done") {
+      lines.push(`**${item.result.title}**`);
+      lines.push(`URL: ${item.result.url}`);
+      lines.push(`Words: ${item.result.wordCount}`);
+      lines.push("");
+
+      // Content preview
+      const preview = truncatePreview(item.result.content);
+      lines.push(preview);
+
+      if (item.result.content.split("\n").length > PREVIEW_LINES) {
+        lines.push("...");
+      }
+    } else {
+      lines.push(`URL: ${item.error.url || "unknown"}`);
+      lines.push(`Error: ${item.error.error}`);
+    }
+
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Render an error result for display.
+ *
+ * @param error - Fetch error
+ * @returns Formatted string
+ */
+export function renderErrorResult(error: FetchError): string {
+  const lines: string[] = [];
+
+  lines.push(`# Fetch Error`);
+  lines.push("");
+  lines.push(`**${error.error}**`);
+  lines.push("");
+  lines.push(`Code: \`${error.code}\``);
+  lines.push(`Phase: \`${error.phase}\``);
+
+  if (error.url) {
+    lines.push("");
+    lines.push(`URL: ${error.url}`);
+    if (error.finalUrl && error.finalUrl !== error.url) {
+      lines.push(`Final URL: ${error.finalUrl}`);
+    }
+  }
+
+  if (error.statusCode) {
+    lines.push("");
+    lines.push(
+      `HTTP Status: ${error.statusCode}${error.statusText ? ` ${error.statusText}` : ""}`
+    );
+  }
+
+  if (error.retryable) {
+    lines.push("");
+    lines.push(`*This error may be retried.*`);
+  }
+
+  return lines.join("\n");
+}

package/src/tui/settings-dialog.ts

@@ -14,7 +14,11 @@ import {
   isProviderEnabled,
   setProviderEnabled,
   validateApiKeyFormat,
+  loadSmartFetchSettings,
+  saveSmartFetchSettings,
+  resetSmartFetchSettings,
 } from "../settings.js";
+import { BROWSER_PROFILES, OS_PROFILES } from "../engine/profiles.js";
 import { getProviderOptions, getProviderStatuses } from "./provider-selector.js";
 
 /**
@@ -28,6 +32,13 @@ export async function showSettingsDialog(ctx: ExtensionCommandContext): Promise<
   while (running) {
     const options = getProviderOptions();
 
+    // Add smart-fetch defaults option at the top
+    options.unshift({
+      label: "⚡ Smart Fetch Defaults",
+      value: "__smart_fetch__",
+      description: "Configure default browser, OS, and fetch settings",
+    });
+
     // Add exit option
     options.push({
       label: "← Back",
@@ -64,6 +75,12 @@ export async function showSettingsDialog(ctx: ExtensionCommandContext): Promise<
 
     lastSelected = selectedValue;
 
+    // Handle smart-fetch defaults
+    if (selectedValue === "__smart_fetch__") {
+      await configureSmartFetch(ctx);
+      continue;
+    }
+
     // Show provider configuration
     await configureProvider(ctx, selectedValue);
   }
@@ -190,3 +207,154 @@ async function inputApiKey(
     );
   }
 }
+
+/**
+ * Configure smart-fetch defaults.
+ */
+async function configureSmartFetch(
+  ctx: ExtensionCommandContext
+): Promise<void> {
+  const settings = loadSmartFetchSettings();
+
+  const options = [
+    {
+      label: `Browser: ${settings.browser}`,
+      value: "browser",
+      description: "TLS fingerprint browser profile",
+    },
+    {
+      label: `OS: ${settings.os}`,
+      value: "os",
+      description: "OS fingerprint",
+    },
+    {
+      label: `Max Chars: ${settings.maxChars.toLocaleString()}`,
+      value: "maxChars",
+      description: "Maximum content characters",
+    },
+    {
+      label: `Timeout: ${settings.timeoutMs}ms`,
+      value: "timeoutMs",
+      description: "Request timeout",
+    },
+    {
+      label: `Concurrency: ${settings.batchConcurrency}`,
+      value: "batchConcurrency",
+      description: "Batch concurrent requests",
+    },
+    {
+      label: `Remove Images: ${settings.removeImages ? "Yes" : "No"}`,
+      value: "removeImages",
+      description: "Strip image references",
+    },
+    {
+      label: `Include Replies: ${settings.includeReplies}`,
+      value: "includeReplies",
+      description: "Include comments/replies",
+    },
+    {
+      label: "Reset to Defaults",
+      value: "__reset__",
+      description: "Reset all settings to defaults",
+    },
+    {
+      label: "← Back",
+      value: "__back__",
+      description: "Return to main menu",
+    },
+  ];
+
+  const labels = options.map(o => `${o.label} — ${o.description}`);
+  const selected = await ctx.ui.select("Smart Fetch Defaults", labels);
+  const selectedOpt = options.find(o => `${o.label} — ${o.description}` === selected);
+  const selectedValue = selectedOpt?.value;
+
+  switch (selectedValue) {
+    case "browser": {
+      const browserOptions = [...BROWSER_PROFILES].reverse(); // Show newest first
+      const browser = await ctx.ui.select("Browser Profile", browserOptions);
+      if (browser) {
+        saveSmartFetchSettings({ browser });
+        ctx.ui.notify(`Browser set to ${browser}`, "info");
+      }
+      break;
+    }
+
+    case "os": {
+      const os = await ctx.ui.select("OS Fingerprint", [...OS_PROFILES]);
+      if (os) {
+        saveSmartFetchSettings({ os });
+        ctx.ui.notify(`OS set to ${os}`, "info");
+      }
+      break;
+    }
+
+    case "maxChars": {
+      const input = await ctx.ui.input("Max Characters", String(settings.maxChars));
+      if (input) {
+        const maxChars = parseInt(input, 10);
+        if (!isNaN(maxChars) && maxChars > 0) {
+          saveSmartFetchSettings({ maxChars });
+          ctx.ui.notify(`Max chars set to ${maxChars.toLocaleString()}`, "info");
+        }
+      }
+      break;
+    }
+
+    case "timeoutMs": {
+      const input = await ctx.ui.input("Timeout (ms)", String(settings.timeoutMs));
+      if (input) {
+        const timeoutMs = parseInt(input, 10);
+        if (!isNaN(timeoutMs) && timeoutMs > 0) {
+          saveSmartFetchSettings({ timeoutMs });
+          ctx.ui.notify(`Timeout set to ${timeoutMs}ms`, "info");
+        }
+      }
+      break;
+    }
+
+    case "batchConcurrency": {
+      const input = await ctx.ui.input("Batch Concurrency", String(settings.batchConcurrency));
+      if (input) {
+        const batchConcurrency = parseInt(input, 10);
+        if (!isNaN(batchConcurrency) && batchConcurrency > 0) {
+          saveSmartFetchSettings({ batchConcurrency });
+          ctx.ui.notify(`Concurrency set to ${batchConcurrency}`, "info");
+        }
+      }
+      break;
+    }
+
+    case "removeImages": {
+      const removeImages = await ctx.ui.select("Remove Images", ["Yes", "No"]);
+      if (removeImages) {
+        saveSmartFetchSettings({ removeImages: removeImages === "Yes" });
+        ctx.ui.notify(`Remove images set to ${removeImages}`, "info");
+      }
+      break;
+    }
+
+    case "includeReplies": {
+      const includeReplies = await ctx.ui.select("Include Replies", [
+        "extractors",
+        "Yes",
+        "No",
+      ]);
+      if (includeReplies) {
+        const value = includeReplies === "Yes" ? true : includeReplies === "No" ? false : "extractors";
+        saveSmartFetchSettings({ includeReplies: value as boolean | "extractors" });
+        ctx.ui.notify(`Include replies set to ${includeReplies}`, "info");
+      }
+      break;
+    }
+
+    case "__reset__":
+      resetSmartFetchSettings();
+      ctx.ui.notify("Smart-fetch settings reset to defaults", "info");
+      break;
+
+    case "__back__":
+    default:
+      break;
+  }
+}