@tomako/tools-runtime 0.1.0

package/src/lib/tools/pitch-deck-generator-schema.ts

@@ -0,0 +1,182 @@
+import { z } from "zod";
+
+export const PITCH_DECK_RESULT_TYPE = "pitch_deck_image_deck";
+export const PITCH_DECK_SCENE = "pitch_deck_generator";
+export const PITCH_DECK_PROMPT_VERSION = "pitch-deck-generator.v1";
+
+export const pitchDeckContextModeSchema = z.enum(["url", "manual"]);
+export const pitchDeckLanguageSchema = z.enum(["zh", "en"]);
+export const pitchDeckFundingStageSchema = z.enum([
+  "preSeed",
+  "seed",
+  "seriesA",
+  "notSure",
+]);
+export const pitchDeckStylePresetSchema = z.enum([
+  "none",
+  "boldNarrative",
+  "metricGrid",
+  "visionField",
+]);
+
+export const PITCH_DECK_LANGUAGES = pitchDeckLanguageSchema.options;
+export const PITCH_DECK_FUNDING_STAGES = pitchDeckFundingStageSchema.options;
+export const PITCH_DECK_STYLE_PRESETS = pitchDeckStylePresetSchema.options;
+
+const optionalText = (max = 1200) => z.string().trim().max(max).optional().default("");
+
+export const pitchDeckInputSchema = z
+  .object({
+    contextMode: pitchDeckContextModeSchema.default("url"),
+    productUrl: z.string().trim().max(240).optional().default(""),
+    productName: optionalText(100),
+    productContext: optionalText(2000),
+    fundingStage: pitchDeckFundingStageSchema.default("notSure"),
+    stylePreset: pitchDeckStylePresetSchema.default("none"),
+    language: pitchDeckLanguageSchema.default("zh"),
+    brandNotes: optionalText(1000),
+    mustAvoid: optionalText(800),
+  })
+  .superRefine((value, ctx) => {
+    if (value.contextMode === "url") {
+      const parsed = z.url().safeParse(value.productUrl);
+      if (!parsed.success) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["productUrl"],
+          message: "A valid product URL is required in URL mode.",
+        });
+      }
+    }
+    if (value.contextMode === "manual") {
+      if (value.productName.trim().length < 1) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["productName"],
+          message: "Manual mode needs a product name.",
+        });
+      }
+      if (value.productContext.trim().length < 24) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["productContext"],
+          message: "Manual mode needs a useful product background.",
+        });
+      }
+    }
+  });
+
+export const pitchDeckThinkingStepSchema = z.object({
+  id: z.string().trim().min(1).max(80),
+  title: z.string().trim().min(1).max(120),
+  status: z.enum(["done", "active", "queued", "blocked"]).default("queued"),
+  detail: z.string().trim().max(360).optional(),
+});
+
+export const pitchDeckOutlineSlideSchema = z.object({
+  index: z.number().int().min(1).max(40),
+  slug: z.string().trim().min(1).max(80),
+  title: z.string().trim().min(1).max(120),
+  coreMessage: z.string().trim().min(1).max(260),
+  density: z.enum(["low", "medium", "high"]).default("medium"),
+  visualRole: z.string().trim().max(180).optional(),
+});
+
+export const pitchDeckSlideSchema = z.object({
+  index: z.number().int().min(1).max(40),
+  slug: z.string().trim().min(1).max(80),
+  title: z.string().trim().min(1).max(120),
+  coreMessage: z.string().trim().max(260).optional(),
+  status: z.enum(["queued", "generating", "ready", "failed"]).default("queued"),
+  imageTaskId: z.string().trim().min(1).max(120).optional(),
+  imageUrl: z.url().optional(),
+  downloadUrl: z.url().optional(),
+  filename: z.string().trim().min(1).max(160).optional(),
+  qaNotes: z.array(z.string().trim().min(1).max(300)).default([]),
+});
+
+export const pitchDeckDownloadsSchema = z.object({
+  packageUrl: z.url().optional(),
+  contactSheetUrl: z.url().optional(),
+  outlineUrl: z.url().optional(),
+  manifestUrl: z.url().optional(),
+});
+
+export const pitchDeckResultSchema = z.object({
+  resultStatus: z.enum(["partial", "final"]).default("final"),
+  brandName: z.string().trim().min(1).max(120),
+  summary: z.string().trim().min(1).max(800),
+  fundingStage: pitchDeckFundingStageSchema.default("notSure"),
+  stylePreset: pitchDeckStylePresetSchema.default("none"),
+  language: pitchDeckLanguageSchema.default("zh"),
+  thinkingSteps: z.array(pitchDeckThinkingStepSchema).min(1).max(12),
+  inProgressSection: z.string().trim().max(160).optional(),
+  completedSections: z.array(z.string().trim().min(1).max(120)).default([]),
+  outline: z.array(pitchDeckOutlineSlideSchema).min(1).max(40),
+  slides: z.array(pitchDeckSlideSchema).default([]),
+  downloads: pitchDeckDownloadsSchema.default({}),
+  sources: z.array(z.string().trim().min(1).max(500)).default([]),
+  missingInfo: z.array(z.string().trim().min(1).max(500)).default([]),
+  qaNotes: z.array(z.string().trim().min(1).max(500)).default([]),
+  promptVersion: z.string().trim().min(1).max(120).default(PITCH_DECK_PROMPT_VERSION),
+  generatedAt: z.string().trim().max(80).optional(),
+});
+
+export type PitchDeckContextMode = z.infer<typeof pitchDeckContextModeSchema>;
+export type PitchDeckLanguage = z.infer<typeof pitchDeckLanguageSchema>;
+export type PitchDeckFundingStage = z.infer<typeof pitchDeckFundingStageSchema>;
+export type PitchDeckStylePreset = z.infer<typeof pitchDeckStylePresetSchema>;
+export type PitchDeckInput = z.infer<typeof pitchDeckInputSchema>;
+export type PitchDeckThinkingStep = z.infer<typeof pitchDeckThinkingStepSchema>;
+export type PitchDeckOutlineSlide = z.infer<typeof pitchDeckOutlineSlideSchema>;
+export type PitchDeckSlide = z.infer<typeof pitchDeckSlideSchema>;
+export type PitchDeckResult = z.infer<typeof pitchDeckResultSchema>;
+
+function orderedSlides(result: PitchDeckResult) {
+  return [...result.slides].sort((a, b) => a.index - b.index);
+}
+
+export function pitchDeckFileBase(productName: string): string {
+  return (
+    productName
+      .trim()
+      .toLowerCase()
+      .replace(/[^a-z0-9一-龥]+/gi, "-")
+      .replace(/^-+|-+$/g, "") || "pitch-deck"
+  );
+}
+
+export function stringifyPitchDeckManifest(result: PitchDeckResult): string {
+  const outline = result.outline
+    .map((slide) => `${slide.index}. ${slide.title} - ${slide.coreMessage}`)
+    .join("\n");
+  const slides = orderedSlides(result)
+    .map((slide) => {
+      const url = slide.downloadUrl || slide.imageUrl || "";
+      return `${slide.index}. ${slide.filename || slide.slug}.png${url ? ` - ${url}` : ""}`;
+    })
+    .join("\n");
+  const sources = result.sources.length
+    ? `\n\n## Sources\n${result.sources.map((item) => `- ${item}`).join("\n")}`
+    : "";
+  const qa = result.qaNotes.length
+    ? `\n\n## QA Notes\n${result.qaNotes.map((item) => `- ${item}`).join("\n")}`
+    : "";
+
+  return `# ${result.brandName} Pitch Deck
+
+${result.summary}
+
+Status: ${result.resultStatus}
+Funding stage: ${result.fundingStage}
+Style: ${result.stylePreset}
+
+## Outline
+${outline}
+
+## Slides
+${slides || "No generated slide images returned yet."}
+${sources}
+${qa}
+`;
+}

package/src/lib/tools/product-agreement-generator-schema.ts

@@ -0,0 +1,168 @@
+import { z } from "zod";
+
+export const productAgreementProductTypeSchema = z.enum([
+  "mobileApp",
+  "webApp",
+  "saas",
+  "ecommerce",
+  "developerTool",
+  "aiProduct",
+]);
+
+export const productAgreementRegionSchema = z.enum([
+  "mainlandChina",
+  "global",
+  "us",
+  "eu",
+]);
+
+export const productAgreementDataCategorySchema = z.enum([
+  "account",
+  "contact",
+  "device",
+  "location",
+  "payment",
+  "content",
+  "analytics",
+  "cookies",
+  "aiInput",
+  "children",
+]);
+
+export const productAgreementFeatureSchema = z.enum([
+  "login",
+  "payments",
+  "subscription",
+  "analytics",
+  "ads",
+  "userContent",
+  "messaging",
+  "aiFeature",
+  "thirdPartyIntegrations",
+  "exportData",
+]);
+
+export const productAgreementDocumentSchema = z.enum([
+  "privacyPolicy",
+  "termsOfService",
+  "cookiePolicy",
+  "dataProcessingAddendum",
+  "accountDeletion",
+  "childrenPrivacy",
+]);
+
+export const productAgreementInputSchema = z.object({
+  productName: z.string().trim().min(1).max(80),
+  operatorName: z.string().trim().max(100).optional().default(""),
+  productUrl: z.string().trim().max(160).optional().default(""),
+  contactEmail: z.string().trim().max(120).optional().default(""),
+  productDescription: z.string().trim().min(10).max(900),
+  productType: productAgreementProductTypeSchema.default("saas"),
+  primaryRegion: productAgreementRegionSchema.default("mainlandChina"),
+  dataCategories: z.array(productAgreementDataCategorySchema).max(10).default([]),
+  features: z.array(productAgreementFeatureSchema).max(10).default([]),
+  documents: z.array(productAgreementDocumentSchema).min(1).max(6),
+});
+
+export type ProductAgreementProductType = z.infer<
+  typeof productAgreementProductTypeSchema
+>;
+export type ProductAgreementRegion = z.infer<typeof productAgreementRegionSchema>;
+export type ProductAgreementDataCategory = z.infer<
+  typeof productAgreementDataCategorySchema
+>;
+export type ProductAgreementFeature = z.infer<typeof productAgreementFeatureSchema>;
+export type ProductAgreementDocumentType = z.infer<
+  typeof productAgreementDocumentSchema
+>;
+export type ProductAgreementInput = z.infer<typeof productAgreementInputSchema>;
+
+export const productAgreementAgentRiskLevelSchema = z.enum([
+  "info",
+  "warning",
+  "critical",
+]);
+
+export const productAgreementAgentRiskFlagSchema = z.object({
+  level: productAgreementAgentRiskLevelSchema,
+  label: z.string().trim().min(1).max(120),
+  detail: z.string().trim().min(1).max(800),
+});
+
+export const productAgreementAgentDocumentSchema = z.object({
+  type: z.string().trim().min(1).max(80),
+  title: z.string().trim().min(1).max(180),
+  summary: z.string().trim().max(600).optional(),
+  markdown: z.string().trim().min(20),
+});
+
+export const productAgreementAgentResultSchema = z.object({
+  summary: z.string().trim().min(1).max(1200),
+  documents: z.array(productAgreementAgentDocumentSchema).min(1).max(8),
+  reviewChecklist: z.array(z.string().trim().min(1).max(600)).default([]),
+  jurisdictionNotes: z.array(z.string().trim().min(1).max(600)).default([]),
+  missingInfo: z.array(z.string().trim().min(1).max(600)).default([]),
+  riskFlags: z.array(productAgreementAgentRiskFlagSchema).default([]),
+  disclaimer: z.string().trim().min(1).max(1200),
+  promptVersion: z.string().trim().min(1).max(120),
+  sourceUrl: z.string().trim().max(500).optional(),
+  generatedAt: z.string().trim().max(80).optional(),
+});
+
+export type ProductAgreementAgentRiskLevel = z.infer<
+  typeof productAgreementAgentRiskLevelSchema
+>;
+export type ProductAgreementAgentRiskFlag = z.infer<
+  typeof productAgreementAgentRiskFlagSchema
+>;
+export type ProductAgreementAgentDocument = z.infer<
+  typeof productAgreementAgentDocumentSchema
+>;
+export type ProductAgreementAgentResult = z.infer<
+  typeof productAgreementAgentResultSchema
+>;
+
+export const PRODUCT_AGREEMENT_PRODUCT_TYPES =
+  productAgreementProductTypeSchema.options;
+export const PRODUCT_AGREEMENT_REGIONS = productAgreementRegionSchema.options;
+export const PRODUCT_AGREEMENT_DATA_CATEGORIES =
+  productAgreementDataCategorySchema.options;
+export const PRODUCT_AGREEMENT_FEATURES = productAgreementFeatureSchema.options;
+export const PRODUCT_AGREEMENT_DOCUMENTS =
+  productAgreementDocumentSchema.options;
+
+export function stringifyAgentAgreementResult(
+  result: ProductAgreementAgentResult,
+  labels: {
+    reviewHeading: string;
+    riskHeading: string;
+    missingInfoHeading: string;
+    jurisdictionHeading: string;
+  },
+): string {
+  const documents = result.documents
+    .map((document) => `${document.title}\n\n${document.markdown}`)
+    .join("\n\n---\n\n");
+  const riskFlags = result.riskFlags.length
+    ? `\n\n${labels.riskHeading}\n${result.riskFlags
+        .map((flag) => `- [${flag.level}] ${flag.label}: ${flag.detail}`)
+        .join("\n")}`
+    : "";
+  const missingInfo = result.missingInfo.length
+    ? `\n\n${labels.missingInfoHeading}\n${result.missingInfo
+        .map((item) => `- ${item}`)
+        .join("\n")}`
+    : "";
+  const jurisdictionNotes = result.jurisdictionNotes.length
+    ? `\n\n${labels.jurisdictionHeading}\n${result.jurisdictionNotes
+        .map((item) => `- ${item}`)
+        .join("\n")}`
+    : "";
+  const reviewChecklist = result.reviewChecklist.length
+    ? `\n\n${labels.reviewHeading}\n${result.reviewChecklist
+        .map((item) => `- ${item}`)
+        .join("\n")}`
+    : "";
+
+  return `${result.summary}\n\n${result.disclaimer}${riskFlags}${missingInfo}${jurisdictionNotes}\n\n${documents}${reviewChecklist}`;
+}

package/src/lib/tools/product-hunt-launch-planner-schema.ts

@@ -0,0 +1,136 @@
+import { z } from "zod";
+import {
+  factClaimContractSchema,
+  makerFirstCommentSchema,
+} from "../../lib/fact-claim-contract";
+
+export const PRODUCT_HUNT_LAUNCH_PLANNER_RESULT_TYPE = "product_hunt_launch_plan";
+export const PRODUCT_HUNT_LAUNCH_PLANNER_SCENE = "product_hunt_launch_planner";
+export const PRODUCT_HUNT_LAUNCH_PLANNER_PROMPT_VERSION =
+  "product-hunt-launch-planner.v1";
+
+export const productHuntLaunchStages = [
+  "idea",
+  "beta",
+  "launched",
+  "majorUpdate",
+] as const;
+
+export const productHuntLaunchGoals = [
+  "feedback",
+  "traffic",
+  "users",
+  "credibility",
+] as const;
+
+export const productHuntAccountStates = ["yes", "no", "unsure"] as const;
+export const productHuntCommunityStates = ["none", "small", "active"] as const;
+export const productHuntAssetStates = ["rough", "some", "ready"] as const;
+export const productHuntPlanItemStatuses = ["ready", "needsWork", "manual"] as const;
+export const productHuntPlanConfidenceLevels = ["low", "medium", "high"] as const;
+
+export const productHuntLaunchBriefSchema = z.object({
+  productName: z.string().trim().min(2).max(80),
+  productUrl: z.string().trim().max(160).optional().or(z.literal("")),
+  oneLiner: z.string().trim().min(24).max(320),
+  audience: z.string().trim().min(8).max(180),
+  launchDate: z.string().trim().max(40).optional().or(z.literal("")),
+  stage: z.enum(productHuntLaunchStages),
+  goal: z.enum(productHuntLaunchGoals),
+  accountState: z.enum(productHuntAccountStates),
+  communityState: z.enum(productHuntCommunityStates),
+  assetState: z.enum(productHuntAssetStates),
+  language: z.enum(["zh", "en"]),
+});
+
+const nonEmptyString = z.string().trim().min(1);
+
+export const productHuntLaunchPlanSchema = z.object({
+  summary: z.object({
+    readinessScore: z.number().min(0).max(100),
+    readinessLabel: nonEmptyString,
+    primaryRisk: nonEmptyString,
+    recommendedLaunchWindow: nonEmptyString,
+  }),
+  checklist: z
+    .array(
+      z.object({
+        phase: nonEmptyString,
+        items: z
+          .array(
+            z.object({
+              title: nonEmptyString,
+              detail: nonEmptyString,
+              owner: nonEmptyString,
+              status: z.enum(productHuntPlanItemStatuses),
+            }),
+          )
+          .min(1),
+      }),
+    )
+    .min(1),
+  assetPack: z.object({
+    taglineOptions: z.array(nonEmptyString).min(1),
+    shortDescription: nonEmptyString,
+    makerComment: nonEmptyString,
+    topics: z.array(nonEmptyString),
+    galleryBrief: z.array(nonEmptyString),
+    thumbnailBrief: nonEmptyString,
+    socialPost: nonEmptyString,
+    supporterNote: nonEmptyString,
+  }),
+  makerFirstComment: makerFirstCommentSchema,
+  launchDay: z
+    .array(
+      z.object({
+        time: nonEmptyString,
+        action: nonEmptyString,
+        owner: nonEmptyString,
+      }),
+    )
+    .min(1),
+  risks: z.array(nonEmptyString),
+  missingInfo: z.array(nonEmptyString),
+  reviewChecklist: z.array(nonEmptyString),
+  factContract: factClaimContractSchema,
+  sources: z
+    .array(
+      z.object({
+        label: nonEmptyString,
+        url: z.string().trim().optional(),
+      }),
+    )
+    .default([]),
+  boundaryNote: z.string().trim().optional(),
+  confidence: z.enum(productHuntPlanConfidenceLevels).optional(),
+  promptVersion: z.literal(PRODUCT_HUNT_LAUNCH_PLANNER_PROMPT_VERSION).optional(),
+  generatedAt: z.string().trim().optional(),
+}).superRefine((plan, context) => {
+  if (plan.makerFirstComment.body !== plan.assetPack.makerComment) {
+    context.addIssue({
+      code: "custom",
+      path: ["makerFirstComment", "body"],
+      message: "maker_comment_body_mismatch",
+    });
+  }
+});
+
+export type ProductHuntLaunchBrief = z.infer<typeof productHuntLaunchBriefSchema>;
+export type ProductHuntLaunchPlan = z.infer<typeof productHuntLaunchPlanSchema>;
+export type ProductHuntLaunchStage = (typeof productHuntLaunchStages)[number];
+export type ProductHuntLaunchGoal = (typeof productHuntLaunchGoals)[number];
+export type ProductHuntAccountState = (typeof productHuntAccountStates)[number];
+export type ProductHuntCommunityState = (typeof productHuntCommunityStates)[number];
+export type ProductHuntAssetState = (typeof productHuntAssetStates)[number];
+
+export interface ProductHuntChecklistItem {
+  title: string;
+  detail: string;
+  owner: string;
+  status: "ready" | "needsWork" | "manual";
+}
+
+export interface ProductHuntChecklistPhase {
+  phase: string;
+  items: ProductHuntChecklistItem[];
+}

package/src/lib/tools/product-hunt-launch-planner.format.ts

@@ -0,0 +1,72 @@
+import type { ProductHuntLaunchPlan } from "./product-hunt-launch-planner-schema";
+
+export function stringifyProductHuntLaunchPlan(plan: ProductHuntLaunchPlan) {
+  const lines = [
+    "# Product Hunt Launch Plan",
+    "",
+    `Readiness: ${plan.summary.readinessScore}/100 - ${plan.summary.readinessLabel}`,
+    `Primary risk: ${plan.summary.primaryRisk}`,
+    `Recommended window: ${plan.summary.recommendedLaunchWindow}`,
+    "",
+    "## Checklist",
+    ...plan.checklist.flatMap((phase) => [
+      "",
+      `### ${phase.phase}`,
+      ...phase.items.map(
+        (item) => `- [ ] ${item.title} (${item.owner}) - ${item.detail}`,
+      ),
+    ]),
+    "",
+    "## Asset Pack",
+    "Taglines:",
+    ...plan.assetPack.taglineOptions.map((item) => `- ${item}`),
+    "",
+    `Short description: ${plan.assetPack.shortDescription}`,
+    "",
+    "Maker comment:",
+    plan.assetPack.makerComment,
+    "",
+    `Topics: ${plan.assetPack.topics.join(", ")}`,
+    "",
+    "Gallery brief:",
+    ...plan.assetPack.galleryBrief.map((item) => `- ${item}`),
+    "",
+    `Thumbnail brief: ${plan.assetPack.thumbnailBrief}`,
+    "",
+    "Social post:",
+    plan.assetPack.socialPost,
+    "",
+    "Supporter note:",
+    plan.assetPack.supporterNote,
+    "",
+    "## Launch Day",
+    ...plan.launchDay.map(
+      (item) => `- ${item.time}: ${item.action} (${item.owner})`,
+    ),
+    "",
+    "## Risks",
+    ...plan.risks.map((item) => `- ${item}`),
+    "",
+    "## Missing Info",
+    ...plan.missingInfo.map((item) => `- ${item}`),
+    "",
+    "## Review Checklist",
+    ...plan.reviewChecklist.map((item) => `- [ ] ${item}`),
+  ];
+
+  if (plan.sources.length) {
+    lines.push(
+      "",
+      "## Sources",
+      ...plan.sources.map((source) =>
+        source.url ? `- ${source.label}: ${source.url}` : `- ${source.label}`,
+      ),
+    );
+  }
+
+  if (plan.boundaryNote) {
+    lines.push("", "## Boundary Note", plan.boundaryNote);
+  }
+
+  return lines.join("\n");
+}