@tomako/tools-runtime 0.1.0

package/src/lib/tools/community-post-risk-checker.format.ts

@@ -0,0 +1,557 @@
+import type {
+  CommunityPostCheckId,
+  CommunityPostCommunity,
+  CommunityPostCtaAdvice,
+  CommunityPostCtaPlan,
+  CommunityPostGoal,
+  CommunityPostLanguage,
+  CommunityPostRiskBrief,
+  CommunityPostRiskCheck,
+  CommunityPostRiskLevel,
+  CommunityPostRiskReport,
+  CommunityPostRiskStatus,
+} from "./community-post-risk-checker-schema";
+
+type CopyPack = {
+  checks: Record<CommunityPostCheckId, string>;
+  verdict: Record<CommunityPostRiskLevel, string>;
+  primaryFix: Record<CommunityPostRiskLevel, string>;
+  cta: Record<
+    "none" | "comment" | "bodyAfterContext" | "onlyIfAsked",
+    CommunityPostCtaAdvice
+  >;
+  fixes: Record<CommunityPostCheckId, string>;
+  reasons: Record<CommunityPostCheckId, (score: number) => string>;
+  flagReasons: Record<
+    "link" | "cta" | "promo" | "missingProcess" | "transparency",
+    string
+  >;
+  flagSuggestion: string;
+  missing: Record<"process" | "numbers" | "audience" | "tradeoff", string>;
+  revisionPlan: Record<
+    "title" | "opening" | "process" | "cta" | "disclosure",
+    string
+  >;
+  checklist: string[];
+};
+
+const copy: Record<CommunityPostLanguage, CopyPack> = {
+  en: {
+    checks: {
+      titlePromotion: "Title promotion risk",
+      ctaTiming: "CTA timing",
+      processEvidence: "Real process evidence",
+      communityTone: "Community tone fit",
+      selfPromotion: "Self-promotion surface",
+      transparency: "Builder disclosure",
+    },
+    verdict: {
+      low: "Low self-promotion risk. The draft reads mostly like a community post, but still needs a final human pass against the subreddit rules.",
+      medium:
+        "Medium risk. The draft has useful context, yet a few sections still feel closer to product marketing than peer discussion.",
+      high: "High risk. This draft is likely to be read as promotional unless the CTA, title, and process evidence are rewritten.",
+    },
+    primaryFix: {
+      low: "Keep the CTA soft and preserve the process details.",
+      medium:
+        "Move the product ask later and add more concrete process, mistakes, or decision tradeoffs.",
+      high: "Remove early conversion language, rewrite the title as a learning question, and add the real story before mentioning the product.",
+    },
+    cta: {
+      none: {
+        placement: "Do not add a CTA in the post",
+        rationale:
+          "For advice or learning posts, the safest path is to ask for discussion rather than clicks.",
+        saferAlternative:
+          "End with one specific question and share the link only if someone asks.",
+      },
+      comment: {
+        placement: "Put the CTA in a first comment",
+        rationale:
+          "Reddit-style communities often punish body links before readers see the process or lesson.",
+        saferAlternative:
+          "Say the post is about the lesson first, then add a transparent comment with the link.",
+      },
+      bodyAfterContext: {
+        placement: "Place a soft CTA near the end of the body",
+        rationale:
+          "The draft has enough process context to support a careful, low-pressure ask.",
+        saferAlternative:
+          "Use wording like: 'Happy to share more context if useful.'",
+      },
+      onlyIfAsked: {
+        placement: "Share the CTA only if asked",
+        rationale:
+          "The current draft has enough promotional surface that a visible CTA would raise moderation risk.",
+        saferAlternative:
+          "Close with a question, then reply with the link only in relevant comment threads.",
+      },
+    },
+    fixes: {
+      titlePromotion:
+        "Rewrite the title as a specific question, lesson, or tradeoff instead of a product claim.",
+      ctaTiming:
+        "Delay the CTA until readers have seen the context, failure, evidence, and ask.",
+      processEvidence:
+        "Add what you tried, what failed, what changed, and one concrete detail from the process.",
+      communityTone:
+        "Use peer-to-peer language, fewer imperatives, and one specific question for the community.",
+      selfPromotion:
+        "Reduce product naming, links, sign-up language, and benefit claims in the body.",
+      transparency:
+        "Disclose your relationship to the product before asking for feedback or clicks.",
+    },
+    reasons: {
+      titlePromotion: (score) =>
+        score > 60
+          ? "The title contains launch, superlative, or benefit-claim language."
+          : "The title is mostly neutral, with limited promotional wording.",
+      ctaTiming: (score) =>
+        score > 60
+          ? "A link or conversion ask appears before the reader gets enough context."
+          : "The CTA is either absent, late, or low-pressure.",
+      processEvidence: (score) =>
+        score > 60
+          ? "The post does not show enough of the real process behind the claim."
+          : "The draft includes some useful process or learning signals.",
+      communityTone: (score) =>
+        score > 60
+          ? "The tone leans toward announcement copy rather than a community discussion."
+          : "The tone is reasonably close to peer discussion.",
+      selfPromotion: (score) =>
+        score > 60
+          ? "Product mentions, links, and benefit language create a self-promotion surface."
+          : "The product surface is controlled enough for a community draft.",
+      transparency: (score) =>
+        score > 60
+          ? "The draft asks readers to engage without clearly stating your relationship to the product."
+          : "The builder relationship is clear enough for a first pass.",
+    },
+    flagReasons: {
+      link: "contains a visible link or domain",
+      cta: "contains a conversion-style CTA",
+      promo: "uses promotional or benefit-claim language",
+      missingProcess: "mentions the product without enough process evidence",
+      transparency: "needs clearer founder/product disclosure",
+    },
+    flagSuggestion:
+      "Rewrite this paragraph around what happened, what you learned, and what you want feedback on.",
+    missing: {
+      process: "Add one concrete step you tried before writing this post.",
+      numbers: "Add a small number, sample size, or time window if it is honest.",
+      audience: "Name who the post is for without turning it into a sales segment.",
+      tradeoff: "Include one tradeoff, failed attempt, or open question.",
+    },
+    revisionPlan: {
+      title: "Make the title less like an ad and more like a specific community question.",
+      opening: "Use the first paragraph to establish context, not the product pitch.",
+      process: "Add the messy middle: attempts, constraints, evidence, and what changed.",
+      cta: "Move the CTA to a comment or remove it until someone asks.",
+      disclosure:
+        "State clearly whether you built, work on, or are affiliated with the product.",
+    },
+    checklist: [
+      "Could a moderator understand the post without clicking anything?",
+      "Does the body contain more learning than product claims?",
+      "Is the CTA optional, late, or comment-only?",
+      "Would the post still be useful if the product name were removed?",
+    ],
+  },
+  zh: {
+    checks: {
+      titlePromotion: "标题广告感",
+      ctaTiming: "CTA 出现时机",
+      processEvidence: "真实过程证据",
+      communityTone: "社区语气匹配",
+      selfPromotion: "自我推广风险",
+      transparency: "身份透明度",
+    },
+    verdict: {
+      low: "低风险。草稿整体像社区讨论，但发布前仍应人工核对对应社区规则。",
+      medium:
+        "中等风险。内容有真实上下文，但部分段落仍接近产品营销，需要降噪。",
+      high: "高风险。标题、CTA 或产品描述会让帖子很容易被读成广告，建议重写后再发。",
+    },
+    primaryFix: {
+      low: "保留过程细节，让 CTA 保持克制。",
+      medium: "把产品请求后移，并补充更具体的过程、失败点或取舍。",
+      high: "先移除早期转化语言，把标题改成学习型问题，再补真实过程后再提产品。",
+    },
+    cta: {
+      none: {
+        placement: "正文里不要放 CTA",
+        rationale: "如果目的是请教或分享经验，最安全的做法是引发讨论，而不是引导点击。",
+        saferAlternative: "结尾只问一个具体问题，只有别人追问时再给链接。",
+      },
+      comment: {
+        placement: "把 CTA 放到首条评论",
+        rationale: "Reddit 类社区通常更敏感正文早期链接，尤其在读者还没看到过程之前。",
+        saferAlternative: "正文先讲经验和问题，再用透明评论补充链接。",
+      },
+      bodyAfterContext: {
+        placement: "可以在正文末尾放一个弱 CTA",
+        rationale: "草稿已有足够过程上下文，可以承载低压力请求。",
+        saferAlternative: "用类似“如果有帮助，我可以补更多上下文”的弱表达。",
+      },
+      onlyIfAsked: {
+        placement: "只有被问到时再发 CTA",
+        rationale: "当前草稿的推广面较强，公开 CTA 会明显增加社区风险。",
+        saferAlternative: "正文以问题收尾，在相关评论线程里再回复链接。",
+      },
+    },
+    fixes: {
+      titlePromotion: "把标题改成具体问题、经验或取舍，不要像产品卖点。",
+      ctaTiming: "等读者看到背景、失败、证据和请求后，再考虑是否出现 CTA。",
+      processEvidence: "补充你试过什么、哪里失败、后来怎么改，以及一个真实细节。",
+      communityTone: "使用同侪讨论语气，减少命令式表达，并提出一个具体问题。",
+      selfPromotion: "减少产品名、链接、注册、试用和收益承诺。",
+      transparency: "在请求反馈或点击前，说明你和产品的关系。",
+    },
+    reasons: {
+      titlePromotion: (score) =>
+        score > 60 ? "标题含有发布、夸张或收益承诺表达。" : "标题整体较克制，广告词不多。",
+      ctaTiming: (score) =>
+        score > 60 ? "链接或转化请求出现得太早。" : "CTA 缺失、靠后或压力较低。",
+      processEvidence: (score) =>
+        score > 60 ? "帖子没有展示足够真实过程。" : "草稿已经包含一些过程或学习信号。",
+      communityTone: (score) =>
+        score > 60 ? "语气更像公告或营销文案，而不是社区讨论。" : "语气基本接近同侪讨论。",
+      selfPromotion: (score) =>
+        score > 60 ? "产品名、链接和卖点形成了明显自我推广面。" : "产品露出目前比较可控。",
+      transparency: (score) =>
+        score > 60 ? "草稿没有清楚说明你与产品的关系。" : "身份关系基本清楚。",
+    },
+    flagReasons: {
+      link: "包含明显链接或域名",
+      cta: "包含转化型 CTA",
+      promo: "使用了推广或卖点表达",
+      missingProcess: "提到产品但缺少过程证据",
+      transparency: "需要更清楚说明身份关系",
+    },
+    flagSuggestion: "把这段改成发生了什么、学到了什么、希望社区反馈什么。",
+    missing: {
+      process: "补一个你实际尝试过的步骤。",
+      numbers: "如果真实，补一个小数字、样本量或时间窗口。",
+      audience: "说明这篇帖子写给谁，但不要写成销售人群标签。",
+      tradeoff: "补一个取舍、失败尝试或开放问题。",
+    },
+    revisionPlan: {
+      title: "把标题从广告式卖点改成具体社区问题。",
+      opening: "第一段先交代背景，不要先推产品。",
+      process: "补充真实过程：尝试、限制、证据和变化。",
+      cta: "把 CTA 移到评论区，或先完全移除。",
+      disclosure: "清楚说明你是否是产品创建者、团队成员或利益相关方。",
+    },
+    checklist: [
+      "不点链接，版主也能理解这篇帖子的价值吗？",
+      "正文里学习过程是否多于产品主张？",
+      "CTA 是否可选、靠后，或只在评论区？",
+      "去掉产品名后，这篇帖子是否仍然有用？",
+    ],
+  },
+};
+
+const promoPatterns = [
+  /\b(best|ultimate|revolutionary|game[-\s]?changing|all[-\s]?in[-\s]?one|#1|10x|viral|growth hack|save hours|scale faster|ai-powered)\b/i,
+  /\b(launch|launched|introducing|free trial|early access|waitlist|book a demo|sign up|subscribe|download|try it)\b/i,
+  /(最强|最好|革命性|颠覆|全能|一站式|爆款|增长神器|节省.*时间|免费试用|立即注册|预约演示|加入等待名单)/i,
+];
+
+const ctaPatterns = [
+  /\b(sign up|join|try|download|subscribe|book a demo|get early access|waitlist|dm me|check it out|give it a try)\b/i,
+  /(注册|试用|下载|预约|加入|私信我|点链接|看看这个|欢迎体验|加入等待名单)/i,
+];
+
+const processPatterns = [
+  /\b(i tried|we tried|what worked|what failed|learned|mistake|tradeoff|constraint|before|after|tested|interviewed|users told us|we found|not sure)\b/i,
+  /(我试了|我们试了|失败|学到|复盘|取舍|限制|之前|之后|测试|访谈|用户说|不确定|踩坑|数据)/i,
+];
+
+const disclosurePatterns = [
+  /\b(i built|we built|my product|our product|i'm building|we're building|i work on|founder|maker|affiliated)\b/i,
+  /(我做的|我们做的|我的产品|我们的产品|我在做|我们在做|创始人|开发者|利益相关|自家产品)/i,
+];
+
+const productPatterns = [
+  /\b(product|app|tool|platform|saas|startup|users|customers|mrr|beta|launch)\b/i,
+  /(产品|工具|平台|应用|SaaS|用户|客户|内测|发布|上线)/i,
+];
+
+const linkPattern =
+  /(https?:\/\/|www\.|[\w-]+\.(?:com|io|ai|app|dev|co|net|org)\b)/i;
+
+function clampScore(score: number) {
+  return Math.max(0, Math.min(100, Math.round(score)));
+}
+
+function scoreToStatus(score: number): CommunityPostRiskStatus {
+  if (score >= 62) return "risk";
+  if (score >= 34) return "watch";
+  return "pass";
+}
+
+function scoreToLevel(score: number): CommunityPostRiskLevel {
+  if (score >= 68) return "high";
+  if (score >= 36) return "medium";
+  return "low";
+}
+
+function countSignals(text: string, patterns: RegExp[]) {
+  return patterns.reduce((total, pattern) => total + (pattern.test(text) ? 1 : 0), 0);
+}
+
+function splitParagraphs(value: string) {
+  return value
+    .split(/\n{2,}/)
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function hasEarlyCta(paragraphs: string[]) {
+  const earlyLimit = Math.max(0, Math.floor(paragraphs.length * 0.35));
+  return paragraphs.some((paragraph, index) => {
+    if (index > earlyLimit) return false;
+    return ctaPatterns.some((pattern) => pattern.test(paragraph)) || linkPattern.test(paragraph);
+  });
+}
+
+function getCtaPlacement({
+  community,
+  ctaPlan,
+  riskScore,
+  linkIncluded,
+  goal,
+}: {
+  community: CommunityPostCommunity;
+  ctaPlan: CommunityPostCtaPlan;
+  riskScore: number;
+  linkIncluded: boolean;
+  goal: CommunityPostGoal;
+}): keyof CopyPack["cta"] {
+  const isReddit = community === "redditSaas" || community === "redditIndieHackers";
+  if (riskScore >= 68) return "onlyIfAsked";
+  if (ctaPlan === "none") return "none";
+  if (isReddit && (linkIncluded || ctaPlan === "body")) return "comment";
+  if (goal === "askAdvice" || goal === "shareLearning") return "none";
+  if (community === "indieHackers" && riskScore < 52) return "bodyAfterContext";
+  return "comment";
+}
+
+function makeCheck(
+  language: CommunityPostLanguage,
+  id: CommunityPostCheckId,
+  score: number,
+): CommunityPostRiskCheck {
+  const pack = copy[language];
+  const cleanScore = clampScore(score);
+  return {
+    id,
+    label: pack.checks[id],
+    status: scoreToStatus(cleanScore),
+    score: cleanScore,
+    reason: pack.reasons[id](cleanScore),
+    fix: pack.fixes[id],
+  };
+}
+
+function buildFlaggedParagraphs(
+  brief: CommunityPostRiskBrief,
+  paragraphs: string[],
+  processSignalCount: number,
+) {
+  const pack = copy[brief.language];
+
+  return paragraphs
+    .map((paragraph, index) => {
+      const reasons: string[] = [];
+      let score = 0;
+
+      if (linkPattern.test(paragraph)) {
+        score += 34;
+        reasons.push(pack.flagReasons.link);
+      }
+      if (countSignals(paragraph, ctaPatterns) > 0) {
+        score += 30;
+        reasons.push(pack.flagReasons.cta);
+      }
+      if (countSignals(paragraph, promoPatterns) > 0) {
+        score += 26;
+        reasons.push(pack.flagReasons.promo);
+      }
+      if (
+        processSignalCount < 2 &&
+        countSignals(paragraph, productPatterns) > 0 &&
+        countSignals(paragraph, processPatterns) === 0
+      ) {
+        score += 22;
+        reasons.push(pack.flagReasons.missingProcess);
+      }
+      if (
+        (brief.ctaPlan === "body" || brief.linkIncluded) &&
+        countSignals(paragraph, disclosurePatterns) === 0 &&
+        index === 0
+      ) {
+        score += 14;
+        reasons.push(pack.flagReasons.transparency);
+      }
+
+      if (score < 30) return null;
+
+      return {
+        index: index + 1,
+        riskLevel: scoreToLevel(score),
+        text: paragraph.length > 260 ? `${paragraph.slice(0, 257)}...` : paragraph,
+        reason: reasons.join("; "),
+        suggestion: pack.flagSuggestion,
+      };
+    })
+    .filter((item): item is NonNullable<typeof item> => item !== null)
+    .slice(0, 5);
+}
+
+export function createCommunityPostRiskReport(
+  brief: CommunityPostRiskBrief,
+): CommunityPostRiskReport {
+  const paragraphs = splitParagraphs(brief.postBody);
+  const combined = `${brief.title}\n${brief.postBody}`;
+  const titlePromoSignals = countSignals(brief.title, promoPatterns);
+  const bodyPromoSignals = countSignals(brief.postBody, promoPatterns);
+  const ctaSignals = countSignals(brief.postBody, ctaPatterns);
+  const processSignalCount = countSignals(combined, processPatterns);
+  const disclosureSignalCount = countSignals(combined, disclosurePatterns);
+  const productSignalCount = countSignals(combined, productPatterns);
+  const strictCommunityBonus =
+    brief.community === "redditSaas" || brief.community === "redditIndieHackers"
+      ? 10
+      : 0;
+  const earlyCta = hasEarlyCta(paragraphs);
+  const linkIncluded = brief.linkIncluded || linkPattern.test(combined);
+
+  const titleScore = clampScore(
+    titlePromoSignals * 28 +
+      (brief.title.length > 95 ? 16 : 0) +
+      (/[!！]{1,}/.test(brief.title) ? 10 : 0),
+  );
+  const ctaScore = clampScore(
+    (brief.ctaPlan === "body" ? 34 : 0) +
+      (brief.ctaPlan === "unsure" ? 12 : 0) +
+      (brief.ctaPlan === "comment" ? 8 : 0) +
+      (linkIncluded ? 22 : 0) +
+      (earlyCta ? 34 : 0) +
+      strictCommunityBonus,
+  );
+  const processScore = clampScore(
+    76 - processSignalCount * 18 + (paragraphs.length < 3 ? 10 : 0),
+  );
+  const toneScore = clampScore(
+    bodyPromoSignals * 18 +
+      ctaSignals * 12 +
+      strictCommunityBonus +
+      (processSignalCount === 0 ? 18 : 0) +
+      ((combined.match(/[!！]/g)?.length ?? 0) > 2 ? 10 : 0),
+  );
+  const selfPromotionScore = clampScore(
+    productSignalCount * 10 +
+      bodyPromoSignals * 16 +
+      ctaSignals * 16 +
+      (linkIncluded ? 22 : 0) +
+      strictCommunityBonus,
+  );
+  const transparencyScore = clampScore(
+    productSignalCount > 0 || linkIncluded || brief.ctaPlan !== "none"
+      ? 66 - disclosureSignalCount * 30 + strictCommunityBonus
+      : 12,
+  );
+
+  const checks = [
+    makeCheck(brief.language, "titlePromotion", titleScore),
+    makeCheck(brief.language, "ctaTiming", ctaScore),
+    makeCheck(brief.language, "processEvidence", processScore),
+    makeCheck(brief.language, "communityTone", toneScore),
+    makeCheck(brief.language, "selfPromotion", selfPromotionScore),
+    makeCheck(brief.language, "transparency", transparencyScore),
+  ];
+
+  const riskScore = clampScore(
+    checks.reduce((total, check) => total + check.score, 0) / checks.length,
+  );
+  const riskLevel = scoreToLevel(riskScore);
+  const ctaKey = getCtaPlacement({
+    community: brief.community,
+    ctaPlan: brief.ctaPlan,
+    riskScore,
+    linkIncluded,
+    goal: brief.goal,
+  });
+  const pack = copy[brief.language];
+
+  return {
+    summary: {
+      riskScore,
+      riskLevel,
+      verdict: pack.verdict[riskLevel],
+      primaryFix: pack.primaryFix[riskLevel],
+      recommendedCtaPlacement: pack.cta[ctaKey].placement,
+    },
+    checks,
+    flaggedParagraphs: buildFlaggedParagraphs(brief, paragraphs, processSignalCount),
+    ctaAdvice: pack.cta[ctaKey],
+    revisionPlan: [
+      pack.revisionPlan.title,
+      pack.revisionPlan.opening,
+      pack.revisionPlan.process,
+      pack.revisionPlan.cta,
+      pack.revisionPlan.disclosure,
+    ],
+    missingInfo: [
+      ...(processSignalCount < 2 ? [pack.missing.process] : []),
+      ...(processSignalCount < 3 ? [pack.missing.tradeoff] : []),
+      ...(productSignalCount > 0 ? [pack.missing.audience] : []),
+      ...(bodyPromoSignals > 0 ? [pack.missing.numbers] : []),
+    ].slice(0, 4),
+    reviewChecklist: pack.checklist,
+    metadata: {
+      community: brief.community,
+      goal: brief.goal,
+      paragraphCount: paragraphs.length,
+      linkIncluded,
+      language: brief.language,
+    },
+  };
+}
+
+export function stringifyCommunityPostRiskReport(report: CommunityPostRiskReport) {
+  const lines = [
+    "# Community Post Risk Checker",
+    "",
+    `Risk score: ${report.summary.riskScore}/100`,
+    `Risk level: ${report.summary.riskLevel}`,
+    `Recommended CTA: ${report.summary.recommendedCtaPlacement}`,
+    "",
+    report.summary.verdict,
+    "",
+    "## Checks",
+    ...report.checks.map(
+      (check) =>
+        `- ${check.label}: ${check.score}/100 (${check.status}) - ${check.fix}`,
+    ),
+    "",
+    "## Flagged paragraphs",
+    ...(report.flaggedParagraphs.length
+      ? report.flaggedParagraphs.map(
+          (item) =>
+            `- Paragraph ${item.index}: ${item.reason}. ${item.suggestion}`,
+        )
+      : ["- None flagged in this pass."]),
+    "",
+    "## CTA advice",
+    `- ${report.ctaAdvice.placement}`,
+    `- ${report.ctaAdvice.rationale}`,
+    `- ${report.ctaAdvice.saferAlternative}`,
+    "",
+    "## Revision plan",
+    ...report.revisionPlan.map((item) => `- ${item}`),
+  ];
+
+  return lines.join("\n");
+}

package/src/lib/tools/competitor-analysis-schema.ts

@@ -0,0 +1,144 @@
+import { z } from "zod";
+
+/** resultType written back by the Skills-OL competitor-analysis skill. */
+export const COMPETITOR_ANALYSIS_RESULT_TYPE = "competitor_analysis";
+
+/** Scene passed to the LLM task (backend treats scene as metadata). */
+export const COMPETITOR_ANALYSIS_SCENE = "competitor_analysis";
+
+export const COMPETITOR_ANALYSIS_PROMPT_VERSION = "competitor-analysis.v1";
+
+// ── Input ────────────────────────────────────────────────────────────────
+
+export const competitorAnalysisInputSchema = z.object({
+  competitorUrl: z
+    .string()
+    .trim()
+    .min(1)
+    .url()
+    .transform((value) => value.replace(/\/$/, "")),
+  competitorName: z.string().trim().max(120).optional(),
+  notes: z.string().trim().max(600).optional(),
+});
+
+export type CompetitorAnalysisInput = z.infer<typeof competitorAnalysisInputSchema>;
+
+// ── Result (tolerant: estimation output may be partial) ────────────────────
+
+const confidence = z.enum(["low", "medium", "high"]).catch("low");
+const trend = z.enum(["growing", "flat", "declining", "unknown"]).catch("unknown");
+
+const trendPoint = z.object({
+  period: z.string(),
+  value: z.number().catch(0),
+});
+
+const sharePoint = z.object({
+  name: z.string(),
+  /** 0-100 percentage when known. */
+  share: z.number().optional(),
+});
+
+const person = z.object({
+  name: z.string(),
+  role: z.string().optional(),
+});
+
+const overviewSchema = z
+  .object({
+    name: z.string().optional(),
+    url: z.string().optional(),
+    tagline: z.string().optional(),
+    description: z.string().optional(),
+    category: z.string().optional(),
+    foundedYear: z.string().optional(),
+    headquarters: z.string().optional(),
+    businessModel: z.string().optional(),
+  })
+  .default({});
+
+const trafficSchema = z
+  .object({
+    summary: z.string().optional(),
+    monthlyVisitsEstimate: z.string().optional(),
+    trend,
+    trendSeries: z.array(trendPoint).default([]),
+    channels: z.array(sharePoint).default([]),
+    geographies: z.array(sharePoint).default([]),
+    confidence,
+  })
+  .default({ trend: "unknown", trendSeries: [], channels: [], geographies: [], confidence: "low" });
+
+const businessScaleSchema = z
+  .object({
+    summary: z.string().optional(),
+    pricingModel: z.string().optional(),
+    priceRange: z.string().optional(),
+    estimatedRevenue: z.string().optional(),
+    employeeRange: z.string().optional(),
+    customerSegments: z.array(z.string()).default([]),
+    notableCustomers: z.array(z.string()).default([]),
+    confidence,
+  })
+  .default({ customerSegments: [], notableCustomers: [], confidence: "low" });
+
+const teamSchema = z
+  .object({
+    summary: z.string().optional(),
+    teamSize: z.string().optional(),
+    founders: z.array(person).default([]),
+    keyPeople: z.array(person).default([]),
+    confidence,
+  })
+  .default({ founders: [], keyPeople: [], confidence: "low" });
+
+const fundingSchema = z
+  .object({
+    summary: z.string().optional(),
+    totalRaised: z.string().optional(),
+    lastRound: z
+      .object({
+        stage: z.string().optional(),
+        amount: z.string().optional(),
+        date: z.string().optional(),
+        leadInvestors: z.array(z.string()).default([]),
+      })
+      .optional(),
+    investors: z.array(z.string()).default([]),
+    confidence,
+  })
+  .default({ investors: [], confidence: "low" });
+
+const positioningSchema = z
+  .object({
+    strengths: z.array(z.string()).default([]),
+    weaknesses: z.array(z.string()).default([]),
+    opportunities: z.array(z.string()).default([]),
+  })
+  .default({ strengths: [], weaknesses: [], opportunities: [] });
+
+const sourceSchema = z.object({
+  label: z.string(),
+  url: z.string().optional(),
+});
+
+export const competitorAnalysisResultSchema = z.object({
+  overview: overviewSchema,
+  traffic: trafficSchema,
+  businessScale: businessScaleSchema,
+  team: teamSchema,
+  funding: fundingSchema,
+  positioning: positioningSchema,
+  highlights: z.array(z.string()).default([]),
+  sources: z.array(sourceSchema).default([]),
+  confidence,
+  summary: z.string(),
+  disclaimer: z.string().default(""),
+  promptVersion: z.string().default(COMPETITOR_ANALYSIS_PROMPT_VERSION),
+  generatedAt: z.string().optional(),
+  sourceUrl: z.string().optional(),
+});
+
+export type CompetitorAnalysisResult = z.infer<typeof competitorAnalysisResultSchema>;
+export type CompetitorConfidence = z.infer<typeof confidence>;
+export type CompetitorTrafficTrend = z.infer<typeof trend>;