@tomako/tools-runtime 0.1.0

package/src/lib/tools/commercial-bp-generator-schema.ts

@@ -0,0 +1,222 @@
+import { z } from "zod";
+
+export const COMMERCIAL_BP_RESULT_TYPE = "commercial_bp_image_deck";
+export const COMMERCIAL_BP_SCENE = "commercial_bp_generator";
+export const COMMERCIAL_BP_PROMPT_VERSION = "commercial-bp-generator.v1";
+
+export const commercialBpContextModeSchema = z.enum(["url", "manual"]);
+export const commercialBpPurposeSchema = z.enum([
+  "fundraising",
+  "recruiting",
+  "launch",
+  "partnership",
+  "strategy",
+  "combined",
+]);
+export const commercialBpLanguageSchema = z.enum(["zh", "en"]);
+export const commercialBpStylePresetSchema = z.enum([
+  "none",
+  "signalEditorial",
+  "operatorGrid",
+  "marketAtlas",
+]);
+export const commercialBpDensitySchema = z.enum(["lean", "standard", "complete"]);
+
+export const COMMERCIAL_BP_PURPOSES = commercialBpPurposeSchema.options;
+export const COMMERCIAL_BP_LANGUAGES = commercialBpLanguageSchema.options;
+export const COMMERCIAL_BP_STYLE_PRESETS = commercialBpStylePresetSchema.options;
+export const COMMERCIAL_BP_DENSITIES = commercialBpDensitySchema.options;
+export const COMMERCIAL_BP_MAX_REFERENCE_IMAGES = 6;
+export const COMMERCIAL_BP_MAX_REFERENCE_IMAGE_CHARS = 900_000;
+
+const optionalText = (max = 1200) => z.string().trim().max(max).optional().default("");
+
+export const commercialBpReferenceImageSchema = z.object({
+  id: z.string().trim().min(1).max(80),
+  name: z.string().trim().min(1).max(160),
+  mimeType: z.enum(["image/jpeg", "image/png", "image/webp"]),
+  size: z.number().int().positive().max(8_000_000),
+  width: z.number().int().positive().max(4096),
+  height: z.number().int().positive().max(4096),
+  dataUrl: z
+    .string()
+    .max(COMMERCIAL_BP_MAX_REFERENCE_IMAGE_CHARS)
+    .refine((value) => value.startsWith("data:image/"), "Reference image must be a data URL."),
+});
+
+export const commercialBpInputSchema = z
+  .object({
+    contextMode: commercialBpContextModeSchema.default("url"),
+    productUrl: z.string().trim().max(240).optional().default(""),
+    productName: optionalText(100),
+    positioning: optionalText(180),
+    targetUsers: optionalText(180),
+    purpose: commercialBpPurposeSchema.default("combined"),
+    productContext: optionalText(2000),
+    brandNotes: optionalText(1000),
+    referenceImages: z
+      .array(commercialBpReferenceImageSchema)
+      .max(COMMERCIAL_BP_MAX_REFERENCE_IMAGES)
+      .optional()
+      .default([]),
+    mustInclude: optionalText(1000),
+    mustAvoid: optionalText(800),
+    stylePreset: commercialBpStylePresetSchema.default("none"),
+    language: commercialBpLanguageSchema.default("zh"),
+    density: commercialBpDensitySchema.default("standard"),
+  })
+  .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" && value.productContext.trim().length < 24) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["productContext"],
+        message: "Manual mode needs a useful product background.",
+      });
+    }
+    if (value.contextMode === "manual" && value.productName.trim().length < 1) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["productName"],
+        message: "Manual mode needs a product name.",
+      });
+    }
+    if (value.contextMode === "manual" && value.positioning.trim().length < 6) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["positioning"],
+        message: "Manual mode needs a useful positioning statement.",
+      });
+    }
+    if (value.contextMode === "manual" && value.targetUsers.trim().length < 2) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["targetUsers"],
+        message: "Manual mode needs target users.",
+      });
+    }
+  });
+
+export const commercialBpThinkingStepSchema = 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 commercialBpOutlineSlideSchema = z.object({
+  index: z.number().int().min(1).max(60),
+  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 commercialBpSlideSchema = z.object({
+  index: z.number().int().min(1).max(60),
+  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 commercialBpDownloadsSchema = z.object({
+  packageUrl: z.url().optional(),
+  contactSheetUrl: z.url().optional(),
+  outlineUrl: z.url().optional(),
+  manifestUrl: z.url().optional(),
+});
+
+export const commercialBpResultSchema = 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),
+  stylePreset: commercialBpStylePresetSchema.default("none"),
+  language: commercialBpLanguageSchema.default("zh"),
+  thinkingSteps: z.array(commercialBpThinkingStepSchema).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(commercialBpOutlineSlideSchema).min(1).max(60),
+  slides: z.array(commercialBpSlideSchema).default([]),
+  downloads: commercialBpDownloadsSchema.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(COMMERCIAL_BP_PROMPT_VERSION),
+  generatedAt: z.string().trim().max(80).optional(),
+});
+
+export type CommercialBpContextMode = z.infer<typeof commercialBpContextModeSchema>;
+export type CommercialBpPurpose = z.infer<typeof commercialBpPurposeSchema>;
+export type CommercialBpLanguage = z.infer<typeof commercialBpLanguageSchema>;
+export type CommercialBpStylePreset = z.infer<typeof commercialBpStylePresetSchema>;
+export type CommercialBpDensity = z.infer<typeof commercialBpDensitySchema>;
+export type CommercialBpReferenceImage = z.infer<typeof commercialBpReferenceImageSchema>;
+export type CommercialBpInput = z.infer<typeof commercialBpInputSchema>;
+export type CommercialBpThinkingStep = z.infer<typeof commercialBpThinkingStepSchema>;
+export type CommercialBpOutlineSlide = z.infer<typeof commercialBpOutlineSlideSchema>;
+export type CommercialBpSlide = z.infer<typeof commercialBpSlideSchema>;
+export type CommercialBpResult = z.infer<typeof commercialBpResultSchema>;
+
+function orderedSlides(result: CommercialBpResult) {
+  return [...result.slides].sort((a, b) => a.index - b.index);
+}
+
+export function commercialBpFileBase(productName: string): string {
+  return (
+    productName
+      .trim()
+      .toLowerCase()
+      .replace(/[^a-z0-9\u4e00-\u9fa5]+/gi, "-")
+      .replace(/^-+|-+$/g, "") || "business-plan-deck"
+  );
+}
+
+export function stringifyCommercialBpManifest(result: CommercialBpResult): 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} Business Plan Deck
+
+${result.summary}
+
+Status: ${result.resultStatus}
+Style: ${result.stylePreset}
+
+## Outline
+${outline}
+
+## Slides
+${slides || "No generated slide images returned yet."}
+${sources}
+${qa}
+`;
+}

package/src/lib/tools/community-feedback-inbox-schema.ts

@@ -0,0 +1,125 @@
+import { z } from "zod";
+
+export const communityFeedbackSources = [
+  "mixed",
+  "reddit",
+  "indieHackers",
+  "hackerNews",
+  "productHunt",
+  "x",
+  "discord",
+] as const;
+
+export const communityFeedbackGoals = [
+  "launchLearning",
+  "betaRecruiting",
+  "roadmap",
+  "landingPage",
+] as const;
+
+export const communityFeedbackCategories = [
+  "pain",
+  "objection",
+  "competitor",
+  "feature",
+  "pricing",
+  "copy",
+] as const;
+
+export const communityFeedbackBriefSchema = z.object({
+  productName: z.string().trim().max(80).optional().or(z.literal("")),
+  productContext: z.string().trim().min(12).max(800),
+  source: z.enum(communityFeedbackSources),
+  goal: z.enum(communityFeedbackGoals),
+  comments: z.string().trim().min(80).max(12000),
+  language: z.enum(["zh", "en"]),
+});
+
+export type CommunityFeedbackBrief = z.infer<
+  typeof communityFeedbackBriefSchema
+>;
+export type CommunityFeedbackSource = (typeof communityFeedbackSources)[number];
+export type CommunityFeedbackGoal = (typeof communityFeedbackGoals)[number];
+export type CommunityFeedbackCategory =
+  (typeof communityFeedbackCategories)[number];
+
+export interface CommunityFeedbackComment {
+  id: string;
+  author: string;
+  source: CommunityFeedbackSource;
+  text: string;
+  categories: CommunityFeedbackCategory[];
+  signalScore: number;
+}
+
+export interface CommunityFeedbackCategorySummary {
+  category: CommunityFeedbackCategory;
+  title: string;
+  count: number;
+  pattern: string;
+  action: string;
+  evidence: string[];
+}
+
+export interface CommunityFeedbackBetaCandidate {
+  author: string;
+  source: CommunityFeedbackSource;
+  score: number;
+  reason: string;
+  inviteDraft: string;
+  evidence: string;
+}
+
+export interface CommunityFeedbackContentAngle {
+  title: string;
+  hook: string;
+  format: string;
+  supportingComment: string;
+}
+
+export interface CommunityFeedbackBacklogItem {
+  title: string;
+  category: CommunityFeedbackCategory;
+  evidenceCount: number;
+  whyItMatters: string;
+  nextAction: string;
+  confidence: "low" | "medium" | "high";
+}
+
+export interface CommunityFeedbackFaqItem {
+  question: string;
+  answerAngle: string;
+  evidence: string;
+}
+
+export interface CommunityFeedbackObjection {
+  title: string;
+  responseAngle: string;
+  evidence: string;
+}
+
+export interface CommunityFeedbackQuote {
+  text: string;
+  category: CommunityFeedbackCategory;
+  source: CommunityFeedbackSource;
+}
+
+export interface CommunityFeedbackInboxReport {
+  summary: {
+    totalComments: number;
+    highSignalCount: number;
+    betaCandidateCount: number;
+    dominantCategory: string;
+    strongestSignal: string;
+    recommendedNextStep: string;
+  };
+  categories: CommunityFeedbackCategorySummary[];
+  betaCandidates: CommunityFeedbackBetaCandidate[];
+  contentAngles: CommunityFeedbackContentAngle[];
+  backlogItems: CommunityFeedbackBacklogItem[];
+  faqItems: CommunityFeedbackFaqItem[];
+  objections: CommunityFeedbackObjection[];
+  quoteBank: CommunityFeedbackQuote[];
+  missingInfo: string[];
+  reviewChecklist: string[];
+}