pi-producthunt 0.1.1

package/lib/client.ts

@@ -0,0 +1,265 @@
+import { executeProductHuntGraphQL } from "./api.ts";
+import { dateRangeForDay, normalizePostIdentifier } from "./identity.ts";
+import { postCommentsQuery, postDetailsQuery, postsQuery, searchPostsQuery, viewerQuery } from "./queries.ts";
+import type {
+  CommentSummary,
+  MakerSummary,
+  PostCommentsResult,
+  PostConnectionResult,
+  PostDetails,
+  PostListItem,
+  ResearchTopicResult,
+  TopicSummary,
+  ViewerResult,
+} from "./types.ts";
+
+type PostsOrder = "RANKING" | "NEWEST";
+type CommentsOrder = "RANKING" | "NEWEST";
+
+interface GraphQLEdge<T> {
+  node: T;
+}
+
+interface GraphQLConnection<T> {
+  edges: Array<GraphQLEdge<T>>;
+  pageInfo?: { hasNextPage: boolean; endCursor?: string | null };
+  totalCount?: number;
+}
+
+interface RawTopic {
+  id?: string;
+  name: string;
+  slug?: string;
+}
+
+interface RawMaker {
+  id?: string;
+  name: string;
+  username?: string | null;
+}
+
+interface RawPostListItem {
+  id: string;
+  slug: string;
+  name: string;
+  tagline?: string | null;
+  url?: string | null;
+  votesCount?: number | null;
+  commentsCount?: number | null;
+  featuredAt?: string | null;
+  createdAt?: string | null;
+  topics?: GraphQLConnection<RawTopic>;
+}
+
+interface RawPostDetails extends RawPostListItem {
+  description?: string | null;
+  website?: string | null;
+  thumbnail?: { url?: string | null } | null;
+  makers?: RawMaker[];
+  user?: RawMaker | null;
+}
+
+interface RawComment {
+  id: string;
+  body: string;
+  votesCount?: number | null;
+  createdAt?: string | null;
+  user?: RawMaker | null;
+  replies?: { totalCount?: number | null } | null;
+}
+
+export interface ProductHuntClientOptions {
+  signal?: AbortSignal;
+  token?: string;
+}
+
+export async function getViewer(options: ProductHuntClientOptions = {}): Promise<ViewerResult> {
+  const result = await executeProductHuntGraphQL<{ viewer?: { user?: { username?: string } | null } | null }>(
+    viewerQuery,
+    {},
+    options,
+  );
+  return { username: result.data.viewer?.user?.username, rateLimit: result.rateLimit };
+}
+
+export async function getPosts(
+  params: {
+    date?: string;
+    topic?: string;
+    featured?: boolean;
+    postedAfter?: string;
+    postedBefore?: string;
+    order?: PostsOrder;
+    limit?: number;
+    after?: string;
+  },
+  options: ProductHuntClientOptions = {},
+): Promise<PostConnectionResult> {
+  const range: { postedAfter?: string; postedBefore?: string } = params.date ? dateRangeForDay(params.date) : {};
+  const first = clampLimit(params.limit, 10, 50);
+  const result = await executeProductHuntGraphQL<{ posts: GraphQLConnection<RawPostListItem> }>(
+    postsQuery,
+    {
+      featured: params.featured,
+      topic: emptyToUndefined(params.topic),
+      postedAfter: params.postedAfter ?? range.postedAfter,
+      postedBefore: params.postedBefore ?? range.postedBefore,
+      order: params.order ?? "RANKING",
+      first,
+      after: params.after,
+    },
+    options,
+  );
+
+  return {
+    posts: result.data.posts.edges.map((edge) => cleanPostListItem(edge.node)),
+    pageInfo: result.data.posts.pageInfo,
+    totalCount: result.data.posts.totalCount,
+    rateLimit: result.rateLimit,
+  };
+}
+
+export async function searchPosts(
+  params: { query: string; limit?: number; searchPool?: number; after?: string },
+  options: ProductHuntClientOptions = {},
+): Promise<PostConnectionResult> {
+  const query = params.query.trim().toLowerCase();
+  if (!query) throw new Error("Search query is required.");
+
+  const searchPool = clampLimit(params.searchPool, 50, 100);
+  const limit = clampLimit(params.limit, 10, 50);
+  const result = await executeProductHuntGraphQL<{ posts: GraphQLConnection<RawPostListItem> }>(
+    searchPostsQuery,
+    { first: searchPool, after: params.after },
+    options,
+  );
+
+  const filtered = result.data.posts.edges
+    .map((edge) => cleanPostListItem(edge.node))
+    .filter((post) => `${post.name} ${post.tagline ?? ""} ${post.topics.map((topic) => topic.name).join(" ")}`.toLowerCase().includes(query))
+    .slice(0, limit);
+
+  return {
+    posts: filtered,
+    pageInfo: result.data.posts.pageInfo,
+    totalCount: filtered.length,
+    rateLimit: result.rateLimit,
+  };
+}
+
+export async function getPost(ref: string, options: ProductHuntClientOptions = {}): Promise<PostDetails> {
+  const identifier = normalizePostIdentifier(ref);
+  const result = await executeProductHuntGraphQL<{ post?: RawPostDetails | null }>(
+    postDetailsQuery,
+    { id: identifier.id, slug: identifier.slug },
+    options,
+  );
+  if (!result.data.post) throw new Error("Product Hunt post not found.");
+  return cleanPostDetails(result.data.post);
+}
+
+export async function getPostComments(
+  params: { ref: string; limit?: number; order?: CommentsOrder; after?: string },
+  options: ProductHuntClientOptions = {},
+): Promise<PostCommentsResult> {
+  const identifier = normalizePostIdentifier(params.ref);
+  const result = await executeProductHuntGraphQL<{
+    post?: { id: string; slug: string; name: string; comments: GraphQLConnection<RawComment> } | null;
+  }>(
+    postCommentsQuery,
+    {
+      postId: identifier.id,
+      postSlug: identifier.slug,
+      order: params.order ?? "RANKING",
+      first: clampLimit(params.limit, 10, 50),
+      after: params.after,
+    },
+    options,
+  );
+
+  if (!result.data.post) throw new Error("Product Hunt post not found.");
+
+  return {
+    post: { id: result.data.post.id, slug: result.data.post.slug, name: result.data.post.name },
+    comments: result.data.post.comments.edges.map((edge) => cleanComment(edge.node)),
+    pageInfo: result.data.post.comments.pageInfo,
+    totalCount: result.data.post.comments.totalCount,
+    rateLimit: result.rateLimit,
+  };
+}
+
+export async function researchTopic(
+  params: { query: string; limit?: number; commentsPerPost?: number },
+  options: ProductHuntClientOptions = {},
+): Promise<ResearchTopicResult> {
+  const posts = await searchPosts({ query: params.query, limit: params.limit ?? 5, searchPool: 75 }, options);
+  const commentsPerPost = clampLimit(params.commentsPerPost, 3, 10);
+  const enriched: ResearchTopicResult["posts"] = [];
+
+  for (const post of posts.posts) {
+    try {
+      const comments = await getPostComments({ ref: post.slug, limit: commentsPerPost }, options);
+      enriched.push({ ...post, comments: comments.comments });
+    } catch {
+      enriched.push(post);
+    }
+  }
+
+  return { query: params.query, posts: enriched, rateLimit: posts.rateLimit };
+}
+
+function cleanPostListItem(raw: RawPostListItem): PostListItem {
+  return {
+    id: raw.id,
+    slug: raw.slug,
+    name: raw.name,
+    tagline: raw.tagline,
+    url: raw.url,
+    votesCount: raw.votesCount,
+    commentsCount: raw.commentsCount,
+    featuredAt: raw.featuredAt,
+    createdAt: raw.createdAt,
+    topics: cleanTopics(raw.topics),
+  };
+}
+
+function cleanPostDetails(raw: RawPostDetails): PostDetails {
+  return {
+    ...cleanPostListItem(raw),
+    description: raw.description,
+    website: raw.website,
+    thumbnailUrl: raw.thumbnail?.url,
+    makers: (raw.makers ?? []).map(cleanMaker),
+    user: raw.user ? cleanMaker(raw.user) : null,
+  };
+}
+
+function cleanComment(raw: RawComment): CommentSummary {
+  return {
+    id: raw.id,
+    body: raw.body,
+    votesCount: raw.votesCount,
+    createdAt: raw.createdAt,
+    user: raw.user ? cleanMaker(raw.user) : null,
+    repliesCount: raw.replies?.totalCount,
+  };
+}
+
+function cleanTopics(connection?: GraphQLConnection<RawTopic>): TopicSummary[] {
+  return connection?.edges.map((edge) => edge.node).map((topic) => ({ id: topic.id, name: topic.name, slug: topic.slug })) ?? [];
+}
+
+function cleanMaker(raw: RawMaker): MakerSummary {
+  return { id: raw.id, name: raw.name, username: raw.username };
+}
+
+function clampLimit(value: number | undefined, fallback: number, max: number): number {
+  if (!value || !Number.isFinite(value)) return fallback;
+  return Math.max(1, Math.min(Math.floor(value), max));
+}
+
+function emptyToUndefined(value: string | undefined): string | undefined {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+

package/lib/config.ts

@@ -0,0 +1,61 @@
+import { clearStoredAccessToken, loadStoredAccessToken, saveStoredAccessToken } from "./auth-store.ts";
+
+export const PRODUCTHUNT_GRAPHQL_ENDPOINT = "https://api.producthunt.com/v2/api/graphql";
+export const PRODUCTHUNT_TOKEN_ENV = "PRODUCTHUNT_ACCESS_TOKEN";
+
+export type AccessTokenSource = "environment" | "stored" | "missing";
+
+export interface ResolvedAccessToken {
+  accessToken?: string;
+  source: AccessTokenSource;
+}
+
+export function resolveProductHuntAccessToken(env: NodeJS.ProcessEnv = process.env): ResolvedAccessToken {
+  const envValue = env[PRODUCTHUNT_TOKEN_ENV]?.trim();
+  if (envValue) {
+    return { accessToken: envValue, source: "environment" };
+  }
+
+  const storedValue = loadStoredAccessToken();
+  if (storedValue) {
+    return { accessToken: storedValue, source: "stored" };
+  }
+
+  return { source: "missing" };
+}
+
+export function getProductHuntToken(env: NodeJS.ProcessEnv = process.env): string {
+  const token = resolveProductHuntAccessToken(env).accessToken;
+  if (!token) {
+    throw new Error(
+      `${PRODUCTHUNT_TOKEN_ENV} is required. Run /producthunt:login or set the env var; do not commit Product Hunt tokens.`,
+    );
+  }
+  return token;
+}
+
+export function isProductHuntConfigured(): boolean {
+  return Boolean(resolveProductHuntAccessToken().accessToken);
+}
+
+export function authStatusText(): string {
+  const { source } = resolveProductHuntAccessToken();
+  if (source === "environment") {
+    return `Product Hunt token: configured via ${PRODUCTHUNT_TOKEN_ENV} environment variable.`;
+  }
+  if (source === "stored") {
+    return "Product Hunt token: configured via pi-producthunt login.";
+  }
+  return `Product Hunt token missing. Run /producthunt:login or set ${PRODUCTHUNT_TOKEN_ENV}.`;
+}
+
+export function redactProductHuntToken(text: string, token?: string): string {
+  let redacted = text.replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/g, "Bearer [REDACTED]");
+  if (token) {
+    redacted = redacted.split(token).join("[REDACTED]");
+  }
+  return redacted;
+}
+
+export { clearStoredAccessToken, loadStoredAccessToken, saveStoredAccessToken };
+

package/lib/format.ts

@@ -0,0 +1,154 @@
+import type { CommentSummary, PostCommentsResult, PostConnectionResult, PostDetails, PostListItem, ResearchTopicResult, ViewerResult } from "./types.ts";
+
+const DEFAULT_MAX_CHARS = 16_000;
+
+export function formatStatus(result: ViewerResult): string {
+  const viewer = result.username ? `@${result.username}` : "token valid; no viewer returned for this token scope";
+  return truncateMarkdown(`Product Hunt API status: ${viewer}${formatRateLimit(result.rateLimit)}`);
+}
+
+export function formatPostList(title: string, result: PostConnectionResult): string {
+  const lines = [`# ${title}`, ""];
+  if (result.posts.length === 0) {
+    lines.push("No Product Hunt posts found.");
+    return lines.join("\n");
+  }
+
+  result.posts.forEach((post, index) => {
+    lines.push(`${index + 1}. ${formatPostHeadline(post)}`);
+    lines.push(`   - ${post.tagline ?? "No tagline"}`);
+    lines.push(`   - votes: ${post.votesCount ?? "?"}, comments: ${post.commentsCount ?? "?"}`);
+    lines.push(`   - slug: ${post.slug}`);
+    if (post.url) lines.push(`   - url: ${post.url}`);
+    if (post.topics.length) lines.push(`   - topics: ${post.topics.map((topic) => topic.name).join(", ")}`);
+  });
+
+  lines.push(formatRateLimit(result.rateLimit));
+  return truncateMarkdown(lines.join("\n"));
+}
+
+export function formatPostDetails(post: PostDetails): string {
+  const lines = [`# ${post.name}`, ""];
+  lines.push(post.tagline ?? "No tagline");
+  lines.push("");
+  if (post.description) lines.push(post.description, "");
+  lines.push(`- slug: ${post.slug}`);
+  lines.push(`- votes: ${post.votesCount ?? "?"}`);
+  lines.push(`- comments: ${post.commentsCount ?? "?"}`);
+  if (post.featuredAt) lines.push(`- featured: ${post.featuredAt}`);
+  if (post.url) lines.push(`- Product Hunt: ${post.url}`);
+  if (post.website) lines.push(`- website: ${post.website}`);
+  if (post.topics.length) lines.push(`- topics: ${post.topics.map((topic) => topic.name).join(", ")}`);
+  if (post.makers.length) lines.push(`- makers: ${post.makers.map(formatMaker).join(", ")}`);
+  return truncateMarkdown(lines.join("\n"));
+}
+
+export function formatComments(result: PostCommentsResult): string {
+  const lines = [`# Comments: ${result.post.name}`, ""];
+  if (!result.comments.length) {
+    lines.push("No comments found.");
+    return lines.join("\n");
+  }
+
+  result.comments.forEach((comment, index) => {
+    lines.push(`## ${index + 1}. ${comment.user ? formatMaker(comment.user) : "Unknown user"}`);
+    lines.push(`votes: ${comment.votesCount ?? "?"}, replies: ${comment.repliesCount ?? 0}`);
+    lines.push("");
+    lines.push(stripHtml(comment.body));
+    lines.push("");
+  });
+
+  lines.push(formatRateLimit(result.rateLimit));
+  return truncateMarkdown(lines.join("\n"));
+}
+
+export function formatDigest(date: string, result: ResearchTopicResult | PostConnectionResult): string {
+  const posts = "query" in result ? result.posts : result.posts;
+  const lines = [`# Product Hunt Digest ${date}`, ""];
+  lines.push("## Top launches");
+  posts.forEach((post, index) => {
+    lines.push(`${index + 1}. ${formatPostHeadline(post)}`);
+    lines.push(`   - tagline: ${post.tagline ?? ""}`);
+    lines.push(`   - votes: ${post.votesCount ?? "?"}, comments: ${post.commentsCount ?? "?"}`);
+    lines.push(`   - url: ${post.url ?? `https://www.producthunt.com/posts/${post.slug}`}`);
+    lines.push("   - why notable: ");
+    const comments = getInlineComments(post);
+    if (comments.length) {
+      lines.push("   - reaction samples:");
+      comments.slice(0, 3).forEach((comment) => {
+        lines.push(`     - ${truncateLine(stripHtml(comment.body), 180)}`);
+      });
+    }
+  });
+
+  lines.push("", "## Signals", "- AI:", "- DevTools:", "- Consumer:", "- Design:", "- Productivity:");
+  lines.push("", "## User reactions", "- Praise:", "- Complaints:", "- Questions:", "- Pricing concerns:");
+  lines.push("", "## Watchlist", "- Product:", "  - reason:", "  - follow-up query:");
+  return truncateMarkdown(lines.join("\n"));
+}
+
+function getInlineComments(post: PostListItem | (PostListItem & { comments?: CommentSummary[] })): CommentSummary[] {
+  const maybeComments = (post as { comments?: unknown }).comments;
+  return Array.isArray(maybeComments) ? (maybeComments as CommentSummary[]) : [];
+}
+
+export function formatResearch(result: ResearchTopicResult): string {
+  const lines = [`# Product Hunt Research: ${result.query}`, ""];
+  if (!result.posts.length) {
+    lines.push("No matching posts found in the current ranking pool.");
+    return lines.join("\n");
+  }
+
+  result.posts.forEach((post, index) => {
+    lines.push(`## ${index + 1}. ${formatPostHeadline(post)}`);
+    lines.push(post.tagline ?? "");
+    lines.push(`votes: ${post.votesCount ?? "?"}, comments: ${post.commentsCount ?? "?"}`);
+    lines.push(`url: ${post.url ?? `https://www.producthunt.com/posts/${post.slug}`}`);
+    if (post.topics.length) lines.push(`topics: ${post.topics.map((topic) => topic.name).join(", ")}`);
+    if (post.comments?.length) {
+      lines.push("", "### Comment signals");
+      post.comments.forEach((comment) => lines.push(`- ${truncateLine(stripHtml(comment.body), 220)}`));
+    }
+    lines.push("");
+  });
+
+  lines.push("## Synthesis prompts", "- Shared positioning pattern:", "- Repeated complaint:", "- Underserved user:", "- Follow-up searches:");
+  return truncateMarkdown(lines.join("\n"));
+}
+
+export function truncateMarkdown(markdown: string, maxChars = DEFAULT_MAX_CHARS): string {
+  if (markdown.length <= maxChars) return markdown;
+  return `${markdown.slice(0, maxChars)}\n\n[Truncated: ${markdown.length - maxChars} chars omitted]`;
+}
+
+function formatPostHeadline(post: PostListItem): string {
+  return `${post.name} (${post.slug})`;
+}
+
+function formatMaker(maker: { name: string; username?: string | null }): string {
+  return maker.username ? `${maker.name} (@${maker.username})` : maker.name;
+}
+
+function formatRateLimit(rateLimit: { limit?: string; remaining?: string; reset?: string } | undefined): string {
+  if (!rateLimit?.remaining) return "";
+  return `\n\nRate limit: ${rateLimit.remaining}/${rateLimit.limit ?? "?"} remaining, reset ${rateLimit.reset ?? "?"}s`;
+}
+
+function stripHtml(text: string): string {
+  return text
+    .replace(/<br\s*\/?>/gi, "\n")
+    .replace(/<[^>]+>/g, "")
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .trim();
+}
+
+function truncateLine(text: string, maxChars: number): string {
+  const singleLine = text.replace(/\s+/g, " ").trim();
+  if (singleLine.length <= maxChars) return singleLine;
+  return `${singleLine.slice(0, maxChars - 1)}…`;
+}
+

package/lib/identity.ts

@@ -0,0 +1,56 @@
+export interface PostIdentifier {
+  id?: string;
+  slug?: string;
+}
+
+export function normalizePostIdentifier(input: string): PostIdentifier {
+  const raw = input.trim();
+  if (!raw) throw new Error("Product Hunt post slug, ID, or URL is required.");
+
+  const urlSlug = extractPostSlugFromUrl(raw);
+  if (urlSlug) return { slug: urlSlug };
+
+  if (/^\d+$/.test(raw)) return { id: raw };
+
+  return { slug: raw.replace(/^@?posts\//, "").replace(/^\//, "") };
+}
+
+function extractPostSlugFromUrl(input: string): string | undefined {
+  let url: URL;
+  try {
+    url = new URL(input);
+  } catch {
+    return undefined;
+  }
+
+  const segments = url.pathname.split("/").filter(Boolean);
+  const postIndex = segments.indexOf("posts");
+  if (postIndex === -1) return undefined;
+
+  const slug = segments[postIndex + 1];
+  return slug ? decodeURIComponent(slug) : undefined;
+}
+
+export function dateRangeForDay(date: string): { postedAfter: string; postedBefore: string } {
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+    throw new Error("Date must use YYYY-MM-DD format.");
+  }
+
+  const start = new Date(`${date}T00:00:00.000Z`);
+  if (Number.isNaN(start.getTime())) throw new Error("Invalid date.");
+
+  const end = new Date(start.getTime() + 24 * 60 * 60 * 1000);
+  return {
+    postedAfter: start.toISOString(),
+    postedBefore: end.toISOString(),
+  };
+}
+
+export function todayIsoDate(now = new Date()): string {
+  return now.toISOString().slice(0, 10);
+}
+
+export function yesterdayIsoDate(now = new Date()): string {
+  return new Date(now.getTime() - 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
+}
+

package/lib/queries.ts

@@ -0,0 +1,89 @@
+export const viewerQuery = `
+  query ProductHuntViewer {
+    viewer { user { username } }
+  }
+`;
+
+export const postsQuery = `
+  query ProductHuntPosts(
+    $featured: Boolean,
+    $topic: String,
+    $postedAfter: DateTime,
+    $postedBefore: DateTime,
+    $order: PostsOrder,
+    $first: Int,
+    $after: String
+  ) {
+    posts(
+      featured: $featured,
+      topic: $topic,
+      postedAfter: $postedAfter,
+      postedBefore: $postedBefore,
+      order: $order,
+      first: $first,
+      after: $after
+    ) {
+      edges {
+        node {
+          id slug name tagline url votesCount commentsCount featuredAt createdAt
+          topics { edges { node { id name slug } } }
+        }
+      }
+      pageInfo { hasNextPage endCursor }
+      totalCount
+    }
+  }
+`;
+
+export const searchPostsQuery = `
+  query ProductHuntSearchPosts($first: Int, $after: String) {
+    posts(order: RANKING, first: $first, after: $after) {
+      edges {
+        node {
+          id slug name tagline url votesCount commentsCount featuredAt createdAt
+          topics { edges { node { id name slug } } }
+        }
+      }
+      pageInfo { hasNextPage endCursor }
+      totalCount
+    }
+  }
+`;
+
+export const postDetailsQuery = `
+  query ProductHuntPost($id: ID, $slug: String) {
+    post(id: $id, slug: $slug) {
+      id slug name tagline description url votesCount commentsCount reviewsRating featuredAt createdAt website
+      thumbnail { url }
+      topics { edges { node { id name slug } } }
+      makers { id name username }
+      user { id name username }
+    }
+  }
+`;
+
+export const postCommentsQuery = `
+  query ProductHuntPostComments(
+    $postId: ID,
+    $postSlug: String,
+    $order: CommentsOrder,
+    $first: Int,
+    $after: String
+  ) {
+    post(id: $postId, slug: $postSlug) {
+      id slug name
+      comments(order: $order, first: $first, after: $after) {
+        edges {
+          node {
+            id body votesCount createdAt
+            user { id name username }
+            replies { totalCount }
+          }
+        }
+        pageInfo { hasNextPage endCursor }
+        totalCount
+      }
+    }
+  }
+`;
+

package/lib/schema.ts

@@ -0,0 +1,8 @@
+import { Type, type TEnum, type TSchemaOptions } from "typebox";
+
+export function StringEnum<const Values extends [string, ...string[]]>(
+  values: readonly [...Values],
+  options?: TSchemaOptions,
+): TEnum<Values> {
+  return Type.Enum([...values] as [string, ...string[]], options) as unknown as TEnum<Values>;
+}