pi-producthunt 0.1.1

package/extensions/index.ts

@@ -0,0 +1,295 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { getPost, getPostComments, getPosts, getViewer, researchTopic, searchPosts } from "../lib/client.ts";
+import { PRODUCTHUNT_TOKEN_ENV, authStatusText, clearStoredAccessToken, saveStoredAccessToken } from "../lib/config.ts";
+import { formatComments, formatDigest, formatPostDetails, formatPostList, formatResearch, formatStatus } from "../lib/format.ts";
+import { todayIsoDate, yesterdayIsoDate } from "../lib/identity.ts";
+import { StringEnum } from "../lib/schema.ts";
+import type { ResearchTopicResult } from "../lib/types.ts";
+
+const emptyParameters = Type.Object({});
+
+const limit = Type.Optional(Type.Integer({ description: "Maximum items to return", minimum: 1, maximum: 50 }));
+
+const getPostsParameters = Type.Object({
+  date: Type.Optional(Type.String({ description: "UTC date in YYYY-MM-DD format" })),
+  topic: Type.Optional(Type.String({ description: "Product Hunt topic slug" })),
+  featured: Type.Optional(Type.Boolean({ description: "Whether to request featured posts" })),
+  order: Type.Optional(StringEnum(["RANKING", "NEWEST"], { description: "Product Hunt posts order" })),
+  limit,
+});
+
+const searchPostsParameters = Type.Object({
+  query: Type.String({ description: "Search keyword or phrase" }),
+  limit,
+  searchPool: Type.Optional(Type.Integer({ description: "Number of ranked posts to scan before filtering", minimum: 1, maximum: 100 })),
+});
+
+const postRefParameters = Type.Object({
+  ref: Type.String({ description: "Product Hunt post slug, numeric ID, or Product Hunt post URL" }),
+});
+
+const commentsParameters = Type.Object({
+  ref: Type.String({ description: "Product Hunt post slug, numeric ID, or Product Hunt post URL" }),
+  limit,
+  order: Type.Optional(StringEnum(["RANKING", "NEWEST"], { description: "Product Hunt comments order" })),
+});
+
+const researchParameters = Type.Object({
+  query: Type.String({ description: "Research topic or keyword" }),
+  limit,
+  commentsPerPost: Type.Optional(Type.Integer({ description: "Comments to collect for each matched post", minimum: 0, maximum: 10 })),
+});
+
+const digestParameters = Type.Object({
+  date: Type.Optional(Type.String({ description: "UTC date in YYYY-MM-DD format. Defaults to today." })),
+  limit,
+  commentsPerPost: Type.Optional(Type.Integer({ description: "Comments to collect for top posts", minimum: 0, maximum: 10 })),
+});
+
+export default function (pi: ExtensionAPI) {
+  registerTools(pi);
+  registerCommands(pi);
+}
+
+function registerTools(pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "producthunt_status",
+    label: "Product Hunt Status",
+    description: "Check Product Hunt API authentication status using PRODUCTHUNT_ACCESS_TOKEN",
+    promptSnippet: "producthunt_status: check Product Hunt API authentication status",
+    promptGuidelines: ["Use producthunt_status before Product Hunt research when authentication may be missing or stale."],
+    parameters: emptyParameters,
+    async execute(_toolCallId, _params, signal) {
+      const result = await getViewer({ signal });
+      return { content: [{ type: "text", text: formatStatus(result) }], details: result };
+    },
+  });
+
+  pi.registerTool({
+    name: "producthunt_get_posts",
+    label: "Product Hunt Posts",
+    description: "Get Product Hunt posts by date, topic, featured flag, or order",
+    promptSnippet: "producthunt_get_posts: fetch Product Hunt launch lists for trend scans",
+    promptGuidelines: ["Use producthunt_get_posts for daily Product Hunt launch scans and digest source material."],
+    parameters: getPostsParameters,
+    async execute(_toolCallId, params, signal) {
+      const result = await getPosts(params, { signal });
+      return { content: [{ type: "text", text: formatPostList("Product Hunt Posts", result) }], details: result };
+    },
+  });
+
+  pi.registerTool({
+    name: "producthunt_search_posts",
+    label: "Product Hunt Search",
+    description: "Search ranked Product Hunt posts by product name, tagline, or topic",
+    promptSnippet: "producthunt_search_posts: search Product Hunt launches by keyword",
+    promptGuidelines: ["Use producthunt_search_posts for Product Hunt competitor or topic research."],
+    parameters: searchPostsParameters,
+    async execute(_toolCallId, params, signal) {
+      const result = await searchPosts(params, { signal });
+      return { content: [{ type: "text", text: formatPostList(`Product Hunt Search: ${params.query}`, result) }], details: result };
+    },
+  });
+
+  pi.registerTool({
+    name: "producthunt_get_post",
+    label: "Product Hunt Post",
+    description: "Get one Product Hunt post by slug, numeric ID, or Product Hunt URL",
+    promptSnippet: "producthunt_get_post: inspect one Product Hunt post in detail",
+    promptGuidelines: ["Use producthunt_get_post before summarizing a specific Product Hunt launch."],
+    parameters: postRefParameters,
+    async execute(_toolCallId, params, signal) {
+      const post = await getPost(params.ref, { signal });
+      return { content: [{ type: "text", text: formatPostDetails(post) }], details: post };
+    },
+  });
+
+  pi.registerTool({
+    name: "producthunt_get_post_comments",
+    label: "Product Hunt Comments",
+    description: "Get comments for one Product Hunt post by slug, numeric ID, or Product Hunt URL",
+    promptSnippet: "producthunt_get_post_comments: collect user reactions from a Product Hunt post",
+    promptGuidelines: ["Use producthunt_get_post_comments to extract praise, complaints, questions, and pricing concerns."],
+    parameters: commentsParameters,
+    async execute(_toolCallId, params, signal) {
+      const result = await getPostComments(params, { signal });
+      return { content: [{ type: "text", text: formatComments(result) }], details: result };
+    },
+  });
+
+  pi.registerTool({
+    name: "producthunt_research_topic",
+    label: "Product Hunt Research",
+    description: "Search Product Hunt and collect comment signals for a research topic",
+    promptSnippet: "producthunt_research_topic: gather Product Hunt posts plus comments for research",
+    promptGuidelines: ["Use producthunt_research_topic when the user asks for Product Hunt market, competitor, or trend research."],
+    parameters: researchParameters,
+    async execute(_toolCallId, params, signal) {
+      const result = await researchTopic(params, { signal });
+      return { content: [{ type: "text", text: formatResearch(result) }], details: result };
+    },
+  });
+
+  pi.registerTool({
+    name: "producthunt_digest",
+    label: "Product Hunt Digest",
+    description: "Create digest-ready Markdown for Product Hunt launches on a date",
+    promptSnippet: "producthunt_digest: prepare Product Hunt daily digest source material",
+    promptGuidelines: ["Use producthunt_digest when the user wants a Product Hunt daily digest or note material."],
+    parameters: digestParameters,
+    async execute(_toolCallId, params, signal) {
+      const date = params.date ?? todayIsoDate();
+      const digest = await buildDigest(date, params.limit ?? 10, params.commentsPerPost ?? 3, signal);
+      return { content: [{ type: "text", text: formatDigest(date, digest) }], details: { date, ...digest } };
+    },
+  });
+}
+
+function registerCommands(pi: ExtensionAPI) {
+  pi.registerCommand("producthunt:status", {
+    description: "Check Product Hunt API authentication status",
+    handler: async (_args, ctx) =>
+      runCommand(pi, ctx, "status", async () => {
+        const auth = authStatusText();
+        const viewer = await getViewer({ signal: ctx.signal });
+        return `${auth}\n\n${formatStatus(viewer)}`;
+      }),
+  });
+
+  pi.registerCommand("producthunt:login", {
+    description: "Enter and store Product Hunt access token via Pi UI",
+    handler: async (_args, ctx) => {
+      const entered = await ctx.ui.input("Product Hunt access token:", "paste access token here");
+      const accessToken = String(entered ?? "").trim();
+      if (!accessToken) {
+        ctx.ui.notify("Product Hunt token was not saved.", "warning");
+        return;
+      }
+
+      saveStoredAccessToken(accessToken);
+      ctx.ui.notify(
+        "Saved Product Hunt token for pi-producthunt. The token was handled by the extension UI and not sent to the model.",
+        "info",
+      );
+    },
+  });
+
+  pi.registerCommand("producthunt:logout", {
+    description: "Remove stored Product Hunt access token from pi-producthunt auth file",
+    handler: async (_args, ctx) => {
+      clearStoredAccessToken();
+      ctx.ui.notify(
+        `${PRODUCTHUNT_TOKEN_ENV} environment variable is unchanged. Removed stored pi-producthunt token.`,
+        "info",
+      );
+    },
+  });
+
+  pi.registerCommand("producthunt:today", {
+    description: "Show today's Product Hunt launches",
+    handler: async (_args, ctx) =>
+      runCommand(pi, ctx, "today", async () => {
+        const date = todayIsoDate();
+        return formatPostList(`Product Hunt Today ${date}`, await getPosts({ date, limit: 10 }, { signal: ctx.signal }));
+      }),
+  });
+
+  pi.registerCommand("producthunt:search", {
+    description: "Interactively search Product Hunt posts",
+    handler: async (_args, ctx) =>
+      runCommand(pi, ctx, "search", async () => {
+        const query = await requiredInput(ctx, "Product Hunt search", "Search keyword or phrase");
+        return formatPostList(`Product Hunt Search: ${query}`, await searchPosts({ query, limit: 10, searchPool: 75 }, { signal: ctx.signal }));
+      }),
+  });
+
+  pi.registerCommand("producthunt:post", {
+    description: "Interactively inspect one Product Hunt post",
+    handler: async (_args, ctx) =>
+      runCommand(pi, ctx, "post", async () => {
+        const ref = await requiredInput(ctx, "Product Hunt post", "Slug, ID, or URL");
+        return formatPostDetails(await getPost(ref, { signal: ctx.signal }));
+      }),
+  });
+
+  pi.registerCommand("producthunt:comments", {
+    description: "Interactively collect Product Hunt post comments",
+    handler: async (_args, ctx) =>
+      runCommand(pi, ctx, "comments", async () => {
+        const ref = await requiredInput(ctx, "Product Hunt comments", "Post slug, ID, or URL");
+        return formatComments(await getPostComments({ ref, limit: 10 }, { signal: ctx.signal }));
+      }),
+  });
+
+  pi.registerCommand("producthunt:digest", {
+    description: "Create Product Hunt digest source material",
+    handler: async (_args, ctx) =>
+      runCommand(pi, ctx, "digest", async () => {
+        const date = await chooseDate(ctx);
+        return formatDigest(date, await buildDigest(date, 10, 3, ctx.signal));
+      }),
+  });
+
+  pi.registerCommand("producthunt:research", {
+    description: "Interactively research a Product Hunt topic",
+    handler: async (_args, ctx) =>
+      runCommand(pi, ctx, "research", async () => {
+        const query = await requiredInput(ctx, "Product Hunt research", "Research topic or keyword");
+        return formatResearch(await researchTopic({ query, limit: 5, commentsPerPost: 3 }, { signal: ctx.signal }));
+      }),
+  });
+}
+
+async function buildDigest(
+  date: string,
+  limit: number,
+  commentsPerPost: number,
+  signal: AbortSignal | undefined,
+): Promise<ResearchTopicResult> {
+  const posts = await getPosts({ date, limit, order: "RANKING" }, { signal });
+  const withComments: ResearchTopicResult["posts"] = [];
+
+  for (const post of posts.posts) {
+    if (commentsPerPost <= 0) {
+      withComments.push(post);
+      continue;
+    }
+
+    try {
+      const comments = await getPostComments({ ref: post.slug, limit: commentsPerPost }, { signal });
+      withComments.push({ ...post, comments: comments.comments });
+    } catch {
+      withComments.push(post);
+    }
+  }
+
+  return { query: date, posts: withComments, rateLimit: posts.rateLimit };
+}
+
+async function runCommand(pi: ExtensionAPI, ctx: ExtensionCommandContext, kind: string, work: () => Promise<string>) {
+  try {
+    const markdown = await work();
+    pi.sendMessage({ customType: "producthunt", content: markdown, display: true, details: { kind } });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    ctx.ui.notify(`Product Hunt error: ${message}`, "error");
+    pi.sendMessage({ customType: "producthunt", content: `Product Hunt error: ${message}`, display: true, details: { kind, error: true } });
+  }
+}
+
+async function requiredInput(ctx: ExtensionCommandContext, title: string, placeholder: string): Promise<string> {
+  if (!ctx.hasUI) throw new Error(`${title} requires interactive input.`);
+  const input = await ctx.ui.input(title, placeholder);
+  const value = input?.trim();
+  if (!value) throw new Error("Input cancelled or empty.");
+  return value;
+}
+
+async function chooseDate(ctx: ExtensionCommandContext): Promise<string> {
+  if (!ctx.hasUI) return todayIsoDate();
+  const choice = await ctx.ui.select("Product Hunt digest date", ["today", "yesterday", "custom"]);
+  if (choice === "yesterday") return yesterdayIsoDate();
+  if (choice === "custom") return requiredInput(ctx, "Product Hunt digest date", "YYYY-MM-DD");
+  return todayIsoDate();
+}

package/lib/api.ts

@@ -0,0 +1,110 @@
+import { PRODUCTHUNT_GRAPHQL_ENDPOINT, getProductHuntToken, redactProductHuntToken } from "./config.ts";
+import type { RateLimitInfo } from "./types.ts";
+
+export class ProductHuntApiError extends Error {
+  readonly status?: number;
+  readonly rateLimit?: RateLimitInfo;
+  readonly graphQLErrors?: unknown[];
+
+  constructor(message: string, options: { status?: number; rateLimit?: RateLimitInfo; graphQLErrors?: unknown[] } = {}) {
+    super(message);
+    this.name = "ProductHuntApiError";
+    this.status = options.status;
+    this.rateLimit = options.rateLimit;
+    this.graphQLErrors = options.graphQLErrors;
+  }
+}
+
+interface GraphQLResponse<T> {
+  data?: T | null;
+  errors?: unknown[];
+}
+
+export interface GraphQLResult<T> {
+  data: T;
+  rateLimit: RateLimitInfo;
+}
+
+export async function executeProductHuntGraphQL<T>(
+  query: string,
+  variables: Record<string, unknown> = {},
+  options: { signal?: AbortSignal; token?: string } = {},
+): Promise<GraphQLResult<T>> {
+  const token = options.token ?? getProductHuntToken();
+
+  const response = await fetch(PRODUCTHUNT_GRAPHQL_ENDPOINT, {
+    method: "POST",
+    signal: options.signal,
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`,
+    },
+    body: JSON.stringify({ query, variables }),
+  });
+
+  const rateLimit = extractRateLimit(response.headers);
+  const text = await response.text();
+  let payload: GraphQLResponse<T> | undefined;
+
+  try {
+    payload = text ? (JSON.parse(text) as GraphQLResponse<T>) : undefined;
+  } catch {
+    throw new ProductHuntApiError(redactProductHuntToken(`Product Hunt returned non-JSON response: ${text}`, token), {
+      status: response.status,
+      rateLimit,
+    });
+  }
+
+  if (!response.ok) {
+    const message = formatGraphQLErrors(payload?.errors) || `Product Hunt request failed with HTTP ${response.status}`;
+    throw new ProductHuntApiError(redactProductHuntToken(message, token), {
+      status: response.status,
+      rateLimit,
+      graphQLErrors: payload?.errors,
+    });
+  }
+
+  if (payload?.errors?.length) {
+    throw new ProductHuntApiError(redactProductHuntToken(formatGraphQLErrors(payload.errors), token), {
+      status: response.status,
+      rateLimit,
+      graphQLErrors: payload.errors,
+    });
+  }
+
+  if (!payload || payload.data == null) {
+    throw new ProductHuntApiError("Product Hunt response did not include data.", { status: response.status, rateLimit });
+  }
+
+  return { data: payload.data, rateLimit };
+}
+
+function extractRateLimit(headers: Headers): RateLimitInfo {
+  return {
+    limit: headers.get("x-rate-limit-limit") ?? undefined,
+    remaining: headers.get("x-rate-limit-remaining") ?? undefined,
+    reset: headers.get("x-rate-limit-reset") ?? undefined,
+  };
+}
+
+function formatGraphQLErrors(errors: unknown[] | undefined): string {
+  if (!errors?.length) return "";
+  return errors
+    .map((error) => {
+      if (typeof error === "string") return error;
+      if (isRecord(error)) {
+        const description = error.error_description;
+        const message = error.message;
+        const code = error.error;
+        return [code, description ?? message].filter((part): part is string => typeof part === "string").join(": ");
+      }
+      return JSON.stringify(error);
+    })
+    .join("; ");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+

package/lib/auth-store.ts

@@ -0,0 +1,68 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const AUTH_FILE_NAME = "pi-producthunt-auth.json";
+
+export interface ProductHuntAuthRecord {
+  type: "access_token";
+  accessToken: string;
+  updatedAt: string;
+}
+
+export function getAgentDir(): string {
+  const override = process.env.PI_PRODUCTHUNT_AGENT_DIR?.trim();
+  if (override) return override;
+  return join(homedir(), ".pi", "agent");
+}
+
+export function getAuthFilePath(): string {
+  return join(getAgentDir(), AUTH_FILE_NAME);
+}
+
+function ensureAgentDir(): void {
+  try {
+    mkdirSync(getAgentDir(), { recursive: true });
+  } catch {
+    // ignore
+  }
+}
+
+export function loadStoredAccessToken(): string | undefined {
+  const file = getAuthFilePath();
+  try {
+    if (!existsSync(file)) return undefined;
+    const parsed = JSON.parse(readFileSync(file, "utf-8")) as Partial<ProductHuntAuthRecord>;
+    if (parsed.type !== "access_token" || typeof parsed.accessToken !== "string") return undefined;
+    const trimmed = parsed.accessToken.trim();
+    return trimmed ? trimmed : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function saveStoredAccessToken(accessToken: string): void {
+  ensureAgentDir();
+  const file = getAuthFilePath();
+  const record: ProductHuntAuthRecord = {
+    type: "access_token",
+    accessToken: accessToken.trim(),
+    updatedAt: new Date().toISOString(),
+  };
+  writeFileSync(file, JSON.stringify(record, null, 2), "utf-8");
+  try {
+    chmodSync(file, 0o600);
+  } catch {
+    // ignore chmod errors on platforms without POSIX modes
+  }
+}
+
+export function clearStoredAccessToken(): void {
+  const file = getAuthFilePath();
+  try {
+    if (existsSync(file)) rmSync(file);
+  } catch {
+    // ignore
+  }
+}
+