@tomako/tools-runtime 0.1.0

package/src/lib/tools/market-forecast-report-schema.ts

@@ -0,0 +1,299 @@
+import { z } from "zod";
+
+export const MARKET_FORECAST_REPORT_RESULT_TYPE = "market_forecast_report";
+export const MARKET_FORECAST_REPORT_SCENE = "market_forecast_report";
+export const MARKET_FORECAST_REPORT_PROMPT_VERSION = "market-forecast-report.v2";
+
+const invalidBriefPattern =
+  /^(test|demo|placeholder|asdf|123|111|hello|hi|market forecast|market size)$/i;
+
+export const marketForecastReportInputSchema = z.object({
+  productContext: z
+    .string()
+    .trim()
+    .min(30)
+    .max(2400)
+    .refine((value) => !invalidBriefPattern.test(value), "placeholder"),
+  productUrl: z.string().trim().max(300).optional(),
+  targetUsers: z.string().trim().min(3).max(600),
+  market: z.string().trim().max(180).optional(),
+  currentUsers: z.string().trim().max(160).optional(),
+  currentRevenue: z.string().trim().max(180).optional(),
+  pricing: z.string().trim().max(220).optional(),
+  paidConversionRate: z.string().trim().max(120).optional(),
+  growthHistory: z.string().trim().max(800).optional(),
+  competitors: z.string().trim().max(800).optional(),
+  communityKeywords: z.string().trim().max(500).optional(),
+  policyNotes: z.string().trim().max(800).optional(),
+  forecastHorizon: z.enum(["one_year", "three_year", "five_year"]).default("three_year"),
+});
+
+export type MarketForecastReportInput = z.infer<typeof marketForecastReportInputSchema>;
+
+const confidence = z.enum(["low", "medium", "high"]).catch("low");
+const evidenceStrength = z.enum(["weak", "mixed", "strong"]).catch("mixed");
+const scenario = z.enum(["bear", "base", "bull"]).catch("base");
+const buyingIntent = z.preprocess((value) => {
+  if (value === true || value === "true") return "clear";
+  if (value === false || value === "false") return "not_observed";
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (["clear", "strong", "explicit", "yes"].includes(normalized)) return "clear";
+    if (["weak", "medium", "mixed"].includes(normalized)) return "weak";
+    if (["none", "false", "no", "not_observed", "not observed"].includes(normalized)) {
+      return "not_observed";
+    }
+  }
+  return value;
+}, z.enum(["clear", "weak", "not_observed", "unknown"]).catch("unknown"));
+const evidenceStatus = z
+  .enum(["source_linked", "source_named", "needs_source", "user_provided"])
+  .catch("needs_source");
+const sourceAccessStatus = z
+  .enum(["verified_accessible", "source_named", "unverified", "inaccessible"])
+  .catch("unverified");
+const sourceFreshness = z
+  .enum(["current", "recent", "stale", "historical", "undated"])
+  .catch("undated");
+const channelRole = z
+  .enum(["core", "supporting", "comparable_only", "excluded"])
+  .catch("supporting");
+const evidenceType = z
+  .enum([
+    "user_provided",
+    "official",
+    "company_disclosure",
+    "community",
+    "search",
+    "news",
+    "policy",
+    "report",
+    "inference",
+    "other",
+  ])
+  .catch("other");
+
+const sourceSchema = z.object({
+  label: z.string(),
+  url: z.string().optional(),
+  type: evidenceType,
+  date: z.string().optional(),
+  accessedAt: z.string().optional(),
+  region: z.string().optional(),
+  note: z.string().optional(),
+  accessStatus: sourceAccessStatus.default("unverified"),
+  freshness: sourceFreshness.default("undated"),
+  confidence,
+});
+
+const evidenceItemSchema = z.object({
+  claim: z.string(),
+  metric: z.string().optional(),
+  channelName: z.string().optional(),
+  channelRole: channelRole.optional(),
+  sourceLabel: z.string(),
+  sourceUrl: z.string().optional(),
+  sourceType: evidenceType,
+  date: z.string().optional(),
+  freshness: sourceFreshness.default("undated"),
+  accessStatus: sourceAccessStatus.default("unverified"),
+  usedForCoreConclusion: z.boolean().default(false),
+  region: z.string().optional(),
+  relevance: z.string(),
+  confidence,
+});
+
+const marketDefinitionSchema = z.object({
+  category: z.string(),
+  targetSegment: z.string(),
+  region: z.string().optional(),
+  tam: z.object({
+    estimate: z.string(),
+    rationale: z.string(),
+    confidence,
+  }),
+  sam: z.object({
+    estimate: z.string(),
+    rationale: z.string(),
+    confidence,
+  }),
+  som: z.object({
+    estimate: z.string(),
+    rationale: z.string(),
+    confidence,
+  }),
+});
+
+const forecastScenarioSchema = z.object({
+  scenario,
+  horizon: z.string(),
+  users: z.string(),
+  paidUsers: z.string(),
+  paidConversionRate: z.string(),
+  arpuOrAcv: z.string(),
+  arr: z.string(),
+  formula: z
+    .object({
+      reachableUsers: z.string().optional(),
+      acquisitionRate: z.string().optional(),
+      activeUsers: z.string().optional(),
+      paidConversionRate: z.string().optional(),
+      arpuOrAcv: z.string().optional(),
+      arrFormula: z.string().optional(),
+      rationale: z.string().optional(),
+    })
+    .optional(),
+  assumptions: z.array(z.string()).default([]),
+  confidence,
+});
+
+const communitySignalSchema = z.object({
+  platform: z.string(),
+  communityOrQuery: z.string(),
+  channelRole: channelRole.optional(),
+  activeSignal: z.string(),
+  buyingIntent: buyingIntent.optional(),
+  repeatedPain: z.string().optional(),
+  observedMetric: z.string().optional(),
+  observedPeriod: z.string().optional(),
+  sampleLinks: z
+    .array(
+      z.object({
+        label: z.string(),
+        url: z.string().optional(),
+        note: z.string().optional(),
+      }),
+    )
+    .default([]),
+  evidenceStatus: evidenceStatus.default("needs_source"),
+  sourceLabel: z.string().optional(),
+  sourceUrl: z.string().optional(),
+  confidence,
+});
+
+const policyTrendSchema = z.object({
+  title: z.string(),
+  direction: z.enum(["tailwind", "headwind", "mixed"]).catch("mixed"),
+  region: z.string().optional(),
+  impactOnAdoption: z.string(),
+  impactOnCostOrSalesCycle: z.string().optional(),
+  sourceLabel: z.string().optional(),
+  sourceUrl: z.string().optional(),
+  confidence,
+});
+
+const sensitivityItemSchema = z.object({
+  variable: z.string(),
+  whyItMatters: z.string(),
+  downsideImpact: z.string(),
+  upsideImpact: z.string(),
+  evidenceStrength,
+});
+
+const evidenceStrengthItemSchema = z.object({
+  sourceType: evidenceType,
+  evidenceCount: z.number().int().nonnegative().default(0),
+  strength: evidenceStrength,
+  note: z.string().optional(),
+});
+
+const comparableCaseSchema = z.object({
+  name: z.string(),
+  comparableDimension: z.string(),
+  relevance: z.string(),
+  limitation: z.string(),
+  sourceLabel: z.string().optional(),
+  sourceUrl: z.string().optional(),
+  confidence,
+});
+
+const dataPointSchema = z.object({
+  label: z.string(),
+  value: z.string(),
+  note: z.string().optional(),
+  sourceLabel: z.string().optional(),
+  sourceUrl: z.string().optional(),
+});
+
+const dataVisualSchema = z.object({
+  title: z.string(),
+  chartType: z.enum(["bar", "funnel", "line", "matrix"]).catch("bar"),
+  summary: z.string(),
+  dataPoints: z.array(dataPointSchema).default([]),
+  confidence,
+});
+
+const evidenceChannelSchema = z.object({
+  name: z.string(),
+  role: channelRole,
+  reason: z.string(),
+  evidenceUse: z.string(),
+  exampleQueries: z.array(z.string()).default([]),
+});
+
+const evidenceChannelPlanSchema = z.object({
+  marketArchetype: z.string().optional(),
+  geo: z.string().optional(),
+  language: z.string().optional(),
+  primaryAudience: z.string().optional(),
+  channelSelectionRationale: z.string().optional(),
+  channels: z.array(evidenceChannelSchema).default([]),
+  excludedChannels: z.array(z.string()).default([]),
+});
+
+const researchProtocolSchema = z.object({
+  marketBoundary: z.string().optional(),
+  primaryMarketDefinition: z.string().optional(),
+  excludedMarkets: z.array(z.string()).default([]),
+  sourceBucketsCovered: z.array(z.string()).default([]),
+  evidenceChannelPlan: evidenceChannelPlanSchema.optional(),
+  recencyRule: z.string().optional(),
+  forecastFormula: z.string().optional(),
+  guardrails: z.array(z.string()).default([]),
+});
+
+const sanityCheckSchema = z.object({
+  name: z.string(),
+  status: z.enum(["pass", "warning", "fail"]).catch("warning"),
+  note: z.string(),
+});
+
+const stabilityCheckSchema = z.object({
+  conclusionBand: z.string().optional(),
+  volatilityRisk: z.enum(["low", "medium", "high"]).catch("medium"),
+  likelyVarianceDrivers: z.array(z.string()).default([]),
+  sanityChecks: z.array(sanityCheckSchema).default([]),
+});
+
+export const marketForecastReportResultSchema = z.object({
+  reportStatus: z.enum(["partial", "final"]).default("final"),
+  completedSections: z.array(z.string()).default([]),
+  inProgressSection: z.string().optional(),
+  reportTitle: z.string().default("Market forecast report"),
+  executiveSummary: z.string().default(""),
+  researchProtocol: researchProtocolSchema.optional(),
+  marketDefinition: marketDefinitionSchema.optional(),
+  forecastScenarios: z.array(forecastScenarioSchema).default([]),
+  evidenceItems: z.array(evidenceItemSchema).default([]),
+  evidenceStrengthBreakdown: z.array(evidenceStrengthItemSchema).default([]),
+  communitySignals: z.array(communitySignalSchema).default([]),
+  policyTrends: z.array(policyTrendSchema).default([]),
+  comparableCases: z.array(comparableCaseSchema).default([]),
+  dataVisuals: z.array(dataVisualSchema).default([]),
+  forecastAssumptions: z.array(z.string()).default([]),
+  sensitivityAnalysis: z.array(sensitivityItemSchema).default([]),
+  investorDiligenceChecklist: z.array(z.string()).default([]),
+  missingEvidence: z.array(z.string()).default([]),
+  sources: z.array(sourceSchema).default([]),
+  stabilityCheck: stabilityCheckSchema.optional(),
+  confidence,
+  boundaryNote: z.string().default(""),
+  disclaimer: z.string().default(""),
+  promptVersion: z.string().default(MARKET_FORECAST_REPORT_PROMPT_VERSION),
+  generatedAt: z.string().optional(),
+});
+
+export type MarketForecastReportResult = z.infer<
+  typeof marketForecastReportResultSchema
+>;
+export type MarketForecastReportConfidence = z.infer<typeof confidence>;

package/src/lib/tools/mcp-registry.ts

@@ -0,0 +1,16 @@
+import registry from "../../generated/mcp-tools-registry.json";
+import type { McpToolRegistryEntry } from "../../lib/tools/mcp-types";
+
+const entries = registry as McpToolRegistryEntry[];
+
+export function listMcpRegistryEntries(): McpToolRegistryEntry[] {
+  return entries;
+}
+
+export function getMcpRegistryEntry(slug: string): McpToolRegistryEntry | undefined {
+  return entries.find((entry) => entry.slug === slug);
+}
+
+export function isMcpToolSlug(slug: string): boolean {
+  return entries.some((entry) => entry.slug === slug);
+}

package/src/lib/tools/mcp-types.ts

@@ -0,0 +1,18 @@
+/** MCP 工具 manifest（与 src/services/tools/manifests/*.json 对齐） */
+export interface McpToolManifest {
+  slug: string;
+  toolName: string;
+  handlerModule: string;
+  inputSchema: Record<string, unknown>;
+}
+
+/** 生成脚本写入，供网站读取 MCP 工具列表（勿手改） */
+export interface McpToolRegistryEntry {
+  slug: string;
+  toolName: string;
+  title: { zh: string; en: string };
+  description: { zh: string; en: string };
+  toolPagePath: string;
+  mcpDocPath: string;
+  updatedAt: string;
+}

package/src/lib/tools/million-user-growth-test-schema.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+
+export const MILLION_USER_GROWTH_TEST_RESULT_TYPE = "million_user_growth_test_result";
+export const MILLION_USER_GROWTH_TEST_SCENE = "million_user_growth_test";
+export const MILLION_USER_GROWTH_TEST_PROMPT_VERSION =
+  "million-user-growth-test.v1";
+
+const emptyToUndefined = (value: unknown) =>
+  typeof value === "string" && value.trim() === "" ? undefined : value;
+
+const trimmedText = (min: number, max: number) =>
+  z.preprocess(emptyToUndefined, z.string().trim().min(min).max(max));
+
+export const millionUserGrowthTestInputSchema = z.object({
+  productName: trimmedText(2, 60),
+  productDescription: trimmedText(8, 220),
+  currentUsers: z.enum(["zero", "under_100", "under_1k", "under_10k", "over_10k"]),
+  growthMotion: z.enum(["content", "ads", "community", "friends", "partnerships", "mysticism"]),
+  founderMode: z.enum(["shipping", "logo_tuning", "pivoting", "waiting", "sales"]),
+});
+
+export type MillionUserGrowthTestInput = z.infer<
+  typeof millionUserGrowthTestInputSchema
+>;
+
+export const millionUserGrowthTestResultSchema = z.object({
+  productName: z.string(),
+  productKeyword: z.string(),
+  score: z.number().min(0).max(100),
+  eta: z.string(),
+  archetype: z.string(),
+  verdict: z.string(),
+  reasons: z.array(z.string()).min(3).max(3),
+  advice: z.string(),
+  shareTitle: z.string(),
+  shareBody: z.string(),
+  tomakoCredit: z.string(),
+  disclaimer: z.string(),
+  inputEcho: millionUserGrowthTestInputSchema.optional(),
+  promptVersion: z.literal(MILLION_USER_GROWTH_TEST_PROMPT_VERSION).optional(),
+  generatedAt: z.string().trim().optional(),
+});
+
+export type MillionUserGrowthTestResult = z.infer<
+  typeof millionUserGrowthTestResultSchema
+>;
+
+export type MillionUserGrowthTestOption =
+  MillionUserGrowthTestInput[keyof MillionUserGrowthTestInput];

package/src/lib/tools/million-user-growth-test.ts

@@ -0,0 +1,181 @@
+import {
+  millionUserGrowthTestInputSchema,
+  millionUserGrowthTestResultSchema,
+  type MillionUserGrowthTestInput,
+  type MillionUserGrowthTestResult,
+} from "./million-user-growth-test-schema";
+
+type TemplateBucket = Record<string, readonly string[]>;
+
+export interface MillionUserGrowthTestCopyBank {
+  eta: TemplateBucket;
+  archetype: TemplateBucket;
+  verdict: TemplateBucket;
+  reasonByUsers: TemplateBucket;
+  reasonByMotion: TemplateBucket;
+  reasonByFounder: TemplateBucket;
+  advice: TemplateBucket;
+  shareTitle: readonly string[];
+  shareBody: readonly string[];
+  tomakoCredit: string;
+  disclaimer: string;
+}
+
+const userWeight: Record<MillionUserGrowthTestInput["currentUsers"], number> = {
+  zero: 7,
+  under_100: 18,
+  under_1k: 34,
+  under_10k: 56,
+  over_10k: 78,
+};
+
+const motionWeight: Record<MillionUserGrowthTestInput["growthMotion"], number> = {
+  content: 10,
+  ads: 7,
+  community: 12,
+  friends: 3,
+  partnerships: 9,
+  mysticism: -6,
+};
+
+const founderWeight: Record<MillionUserGrowthTestInput["founderMode"], number> = {
+  shipping: 13,
+  logo_tuning: -5,
+  pivoting: -3,
+  waiting: -9,
+  sales: 11,
+};
+
+function hashString(value: string) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+
+function pick<T>(items: readonly T[], seed: number, offset = 0): T {
+  return items[(seed + offset) % items.length];
+}
+
+function pickBucket(
+  buckets: TemplateBucket,
+  key: string,
+  seed: number,
+  offset = 0,
+) {
+  const selected = buckets[key] ?? buckets.default ?? [""];
+  return pick(selected, seed, offset);
+}
+
+function bucketScore(score: number) {
+  if (score < 22) return "hopeless";
+  if (score < 42) return "slow";
+  if (score < 62) return "possible";
+  if (score < 82) return "promising";
+  return "rocket";
+}
+
+function extractKeyword(input: MillionUserGrowthTestInput) {
+  const candidates = input.productDescription
+    .replace(/[^\p{L}\p{N}\s-]/gu, " ")
+    .split(/\s+/)
+    .map((part) => part.trim())
+    .filter((part) => part.length >= 2 && !/^(ai|app|tool|saas|product)$/i.test(part));
+
+  return candidates[0] ?? input.productName;
+}
+
+function applyTemplate(
+  template: string,
+  input: MillionUserGrowthTestInput,
+  result: { score: number; productKeyword: string },
+) {
+  return template
+    .replaceAll("{product}", input.productName)
+    .replaceAll("{keyword}", result.productKeyword)
+    .replaceAll("{score}", String(result.score));
+}
+
+export function createMillionUserGrowthTestResult(
+  unsafeInput: MillionUserGrowthTestInput,
+  copyBank: MillionUserGrowthTestCopyBank,
+): MillionUserGrowthTestResult {
+  const input = millionUserGrowthTestInputSchema.parse(unsafeInput);
+  const seed = hashString(
+    [
+      input.productName,
+      input.productDescription,
+      input.currentUsers,
+      input.growthMotion,
+      input.founderMode,
+    ].join("|"),
+  );
+  const rawScore =
+    userWeight[input.currentUsers] +
+    motionWeight[input.growthMotion] +
+    founderWeight[input.founderMode] +
+    (seed % 17) -
+    8;
+  const score = Math.max(0, Math.min(100, rawScore));
+  const scoreBucket = bucketScore(score);
+  const productKeyword = extractKeyword(input);
+  const templateContext = { score, productKeyword };
+
+  const eta = applyTemplate(
+    pickBucket(copyBank.eta, scoreBucket, seed, 1),
+    input,
+    templateContext,
+  );
+  const archetype = applyTemplate(
+    pickBucket(copyBank.archetype, input.founderMode, seed, 2),
+    input,
+    templateContext,
+  );
+  const verdict = applyTemplate(
+    pickBucket(copyBank.verdict, scoreBucket, seed, 3),
+    input,
+    templateContext,
+  );
+  const reasons = [
+    applyTemplate(
+      pickBucket(copyBank.reasonByUsers, input.currentUsers, seed, 4),
+      input,
+      templateContext,
+    ),
+    applyTemplate(
+      pickBucket(copyBank.reasonByMotion, input.growthMotion, seed, 5),
+      input,
+      templateContext,
+    ),
+    applyTemplate(
+      pickBucket(copyBank.reasonByFounder, input.founderMode, seed, 6),
+      input,
+      templateContext,
+    ),
+  ];
+  const advice = applyTemplate(
+    pickBucket(copyBank.advice, scoreBucket, seed, 7),
+    input,
+    templateContext,
+  );
+  const shareTitle = applyTemplate(pick(copyBank.shareTitle, seed, 8), input, templateContext);
+  const shareBody = applyTemplate(pick(copyBank.shareBody, seed, 9), input, templateContext);
+
+  return millionUserGrowthTestResultSchema.parse({
+    productName: input.productName,
+    productKeyword,
+    score,
+    eta,
+    archetype,
+    verdict,
+    reasons,
+    advice,
+    shareTitle,
+    shareBody,
+    tomakoCredit: copyBank.tomakoCredit,
+    disclaimer: copyBank.disclaimer,
+  });
+}
+