@tomako/tools-runtime 0.1.0

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

@@ -0,0 +1,563 @@
+import { z } from "zod";
+
+const PRODUCT_NAME_DEMO_NAMES = new Set([
+  "founos",
+  "mavos",
+  "vokai",
+  "nexai",
+  "doplane",
+  "forgely",
+  "orbitio",
+  "flowkit",
+  "novobase",
+  "flowbase",
+]);
+
+const PRODUCT_NAME_PLACEHOLDERS = new Set([
+  "test",
+  "demo",
+  "asdf",
+  "qwer",
+  "aaaa",
+  "bbbb",
+  "placeholder",
+  "sample",
+  "测试",
+  "產品",
+  "产品",
+  "工具",
+  "名字",
+  "起名",
+  "取名",
+]);
+
+function compactInput(value: string): string {
+  return value.trim().toLowerCase().replace(/\s+/g, "");
+}
+
+function hasMeaningfulProductIdea(value: string): boolean {
+  const compact = compactInput(value);
+  if (!/[A-Za-z\u3400-\u9FFF]/.test(compact)) return false;
+  if (PRODUCT_NAME_PLACEHOLDERS.has(compact)) return false;
+  if (/^(.)\1{3,}$/.test(compact)) return false;
+  return true;
+}
+
+export const productNameStyleSchema = z.enum([
+  "clear",
+  "technical",
+  "friendly",
+  "premium",
+  "invented",
+]);
+
+export const productNameMarketSchema = z.enum([
+  "globalEnglish",
+  "mainlandChina",
+  "us",
+  "eu",
+  "japan",
+  "sea",
+]);
+
+export const productNameTldSchema = z.enum([
+  "ai",
+  "com",
+  "io",
+  "app",
+  "dev",
+  "co",
+  "so",
+  "studio",
+]);
+
+export const productNameInputSchema = z.object({
+  workingName: z.string().trim().max(80).optional().default(""),
+  productDescription: z
+    .string()
+    .trim()
+    .min(4)
+    .max(1200)
+    .refine(hasMeaningfulProductIdea, {
+      message: "description_meaningful",
+    }),
+  targetUsers: z.string().trim().max(400).optional().default(""),
+  desiredVibe: z.string().trim().max(280).optional().default(""),
+  style: productNameStyleSchema.default("clear"),
+  targetMarkets: z.array(productNameMarketSchema).min(1).max(6),
+  tlds: z.array(productNameTldSchema).min(1).max(5),
+  maxPriceUsd: z.coerce.number().int().min(0).max(50000).optional().default(200),
+  allowFallbackDomains: z.boolean().default(true),
+  candidateNames: z.string().trim().max(500).optional().default(""),
+  finalCount: z.coerce.number().int().min(3).max(5).default(5),
+});
+
+export type ProductNameStyle = z.infer<typeof productNameStyleSchema>;
+export type ProductNameMarket = z.infer<typeof productNameMarketSchema>;
+export type ProductNameTld = z.infer<typeof productNameTldSchema>;
+export type ProductNameInput = z.infer<typeof productNameInputSchema>;
+
+export type ProductNameVerdict =
+  | "green"
+  | "light_yellow"
+  | "yellow"
+  | "orange"
+  | "red"
+  | "unknown";
+
+export interface ProductNameCheck {
+  dimension: string;
+  verdict: ProductNameVerdict | string;
+  note?: string;
+}
+
+export interface ProductNameDomainOption {
+  domain: string;
+  status: string;
+  rdapStatus?: string;
+  dnsStatus?: string;
+  estimatedPriceUsd?: string;
+  note?: string;
+}
+
+export interface ProductNameCandidate {
+  name: string;
+  coreIdea: string;
+  basics: string;
+  rationale?: string;
+  pronunciation?: string;
+  verdict: ProductNameVerdict | string;
+  score?: number;
+  stage: "unchecked_idea" | "fast_screened" | "domain_checked" | "deep_researched";
+  tags: string[];
+  domains: ProductNameDomainOption[];
+  checks: ProductNameCheck[];
+}
+
+export interface ProductNameProgressItem {
+  label: string;
+  value: string | number;
+}
+
+export interface ProductNameScreenResult {
+  mode: "screen";
+  summary: string;
+  names: ProductNameCandidate[];
+  progress: ProductNameProgressItem[];
+  artifactLinks?: Record<string, string>;
+  disclaimer: string;
+  promptVersion: string;
+  generatedAt: string;
+}
+
+export interface ProductNameSearchLink {
+  label: string;
+  url: string;
+  note?: string;
+}
+
+export interface ProductNameDetailResult {
+  mode: "detail";
+  name: string;
+  summary: string;
+  coreIdea: string;
+  recommendation: string;
+  domains: ProductNameDomainOption[];
+  seo: {
+    verdict: ProductNameVerdict | string;
+    notes: string[];
+    searchLinks: ProductNameSearchLink[];
+  };
+  trademark: {
+    verdict: ProductNameVerdict | string;
+    notes: string[];
+    officialSources: ProductNameSearchLink[];
+    searchLinks: ProductNameSearchLink[];
+  };
+  risks: string[];
+  nextChecks: string[];
+  disclaimer: string;
+  promptVersion: string;
+  generatedAt: string;
+}
+
+export const PRODUCT_NAME_STYLES = productNameStyleSchema.options;
+export const PRODUCT_NAME_MARKETS = productNameMarketSchema.options;
+export const PRODUCT_NAME_TLDS = productNameTldSchema.options;
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function asString(value: unknown, fallback = ""): string {
+  return typeof value === "string" ? value : fallback;
+}
+
+function asNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function asStringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.map((item) => String(item || "").trim()).filter(Boolean)
+    : [];
+}
+
+function normalizeVerdict(value: unknown): ProductNameVerdict | string {
+  const verdict = asString(value, "unknown");
+  if (verdict === "strong") return "green";
+  if (verdict === "promising") return "light_yellow";
+  if (verdict === "caution") return "yellow";
+  return verdict;
+}
+
+function normalizeBasics(value: unknown): string {
+  if (typeof value === "string") return value;
+  if (!isRecord(value)) return "";
+
+  const parts = [
+    value.syllables ? `${value.syllables} syllables` : "",
+    value.length ? `${value.length} chars` : "",
+    value.pronounce ? `pronounced ${value.pronounce}` : "",
+  ].filter(Boolean);
+
+  return parts.join(" · ");
+}
+
+function normalizeDomainOption(
+  value: unknown,
+  fallbackStatus: string,
+): ProductNameDomainOption | null {
+  if (typeof value === "string") {
+    const domain = value.trim();
+    return domain ? { domain, status: fallbackStatus } : null;
+  }
+
+  if (!isRecord(value)) return null;
+  const domain = asString(value.domain);
+  if (!domain) return null;
+
+  return {
+    domain,
+    status: asString(value.status, fallbackStatus),
+    rdapStatus: asString(value.rdapStatus || value.rdap_status) || undefined,
+    dnsStatus: asString(value.dnsStatus || value.dns_status) || undefined,
+    estimatedPriceUsd: asString(value.estimatedPriceUsd) || undefined,
+    note: asString(value.note) || undefined,
+  };
+}
+
+function normalizeDomainList(
+  value: unknown,
+  fallbackStatus: string,
+): ProductNameDomainOption[] {
+  if (!Array.isArray(value)) return [];
+
+  return value
+    .map((item) => normalizeDomainOption(item, fallbackStatus))
+    .filter((item): item is ProductNameDomainOption => Boolean(item));
+}
+
+function normalizeDomains(value: unknown): ProductNameDomainOption[] {
+  if (Array.isArray(value)) {
+    return normalizeDomainList(value, "unknown");
+  }
+
+  if (!isRecord(value)) return [];
+
+  return [
+    ...normalizeDomainList(value.available, "likely_available"),
+    ...normalizeDomainList(value.registered, "registered"),
+  ];
+}
+
+function normalizeChecks(value: unknown): ProductNameCheck[] {
+  if (Array.isArray(value)) {
+    const checks: ProductNameCheck[] = [];
+    for (const item of value) {
+      if (!isRecord(item)) continue;
+      const dimension = asString(item.dimension);
+      if (!dimension) continue;
+      checks.push({
+        dimension,
+        verdict: normalizeVerdict(item.verdict),
+        note: asString(item.note) || undefined,
+      });
+    }
+    return checks;
+  }
+
+  if (!isRecord(value)) return [];
+
+  return Object.entries(value).map(([dimension, verdict]) => ({
+    dimension,
+    verdict: normalizeVerdict(verdict),
+  }));
+}
+
+function normalizeSearchLinks(value: unknown): ProductNameSearchLink[] {
+  if (!Array.isArray(value)) return [];
+
+  const links: ProductNameSearchLink[] = [];
+  for (const item of value) {
+    if (typeof item === "string") {
+      const url = item.match(/https?:\/\/\S+/)?.[0]?.replace(/[),.;]+$/, "");
+      if (!url) continue;
+      const label = item.replace(url, "").replace(/[—–-]+$/, "").trim() || url;
+      links.push({ label, url });
+      continue;
+    }
+
+    if (!isRecord(item)) continue;
+    const url = asString(item.url);
+    const label = asString(item.label, url);
+    if (!url || !label) continue;
+    links.push({
+      label,
+      url,
+      note: asString(item.note) || undefined,
+    });
+  }
+  return links;
+}
+
+function normalizeCandidate(value: unknown): ProductNameCandidate | null {
+  if (!isRecord(value)) return null;
+  const name = asString(value.name);
+  if (!name) return null;
+
+  const linguistic = isRecord(value.linguistic) ? value.linguistic : null;
+  const domainCheck = isRecord(value.domain) ? value.domain : null;
+  const seoCheck = isRecord(value.seo) ? value.seo : null;
+  const domains = normalizeDomains(value.domains ?? value.domain);
+  const checks = normalizeChecks(value.checks);
+  const seenChecks = new Set(
+    checks.map((check) => check.dimension.toLowerCase()),
+  );
+  const inferredChecks: ProductNameCheck[] = [
+    linguistic
+      ? {
+          dimension: "linguistic",
+          verdict: normalizeVerdict(linguistic.verdict),
+          note: asStringArray(linguistic.flags).join(", ") || undefined,
+        }
+      : null,
+    domainCheck
+      ? {
+          dimension: "domain",
+          verdict: normalizeVerdict(domainCheck.verdict),
+        }
+      : null,
+    seoCheck
+      ? {
+          dimension: "seo",
+          verdict: normalizeVerdict(seoCheck.verdict),
+          note: asString(seoCheck.note) || undefined,
+        }
+      : null,
+  ].filter((item): item is ProductNameCheck => Boolean(item));
+
+  return {
+    name,
+    coreIdea: asString(value.coreIdea || value.meaning || value.rationale, name),
+    basics:
+      normalizeBasics(value.basics ?? linguistic) || asString(value.summary, ""),
+    rationale: asString(value.rationale) || undefined,
+    pronunciation: asString(value.pronunciation) || undefined,
+    verdict: normalizeVerdict(
+      value.verdict ?? value.overall ?? linguistic?.verdict,
+    ),
+    score:
+      asNumber(value.score) ??
+      asNumber(value.overallScore) ??
+      asNumber(linguistic?.score),
+    stage: domains.length ? "domain_checked" : "fast_screened",
+    tags: asStringArray(value.tags).length
+      ? asStringArray(value.tags)
+      : asStringArray(value.labels),
+    domains,
+    checks: [
+      ...checks,
+      ...inferredChecks.filter((check) => {
+        const key = check.dimension.toLowerCase();
+        if (seenChecks.has(key)) return false;
+        seenChecks.add(key);
+        return true;
+      }),
+    ],
+  };
+}
+
+function rawScreenCandidates(value: Record<string, unknown>): unknown[] {
+  if (Array.isArray(value.shortlist)) {
+    const pool = Array.isArray(value.names) ? value.names : [];
+    const byName = new Map(
+      pool
+        .filter(isRecord)
+        .map((item) => [asString(item.name).toLowerCase(), item] as const)
+        .filter(([name]) => Boolean(name)),
+    );
+    const shortlist = value.shortlist
+      .map((item) => {
+        if (isRecord(item)) return item;
+        const name = String(item || "").trim();
+        if (!name) return null;
+        return byName.get(name.toLowerCase()) ?? { name };
+      })
+      .filter(Boolean);
+    if (shortlist.length > 0) return shortlist;
+  }
+  if (Array.isArray(value.finalRecommendations)) return value.finalRecommendations;
+  if (Array.isArray(value.names)) return value.names;
+  return [];
+}
+
+function looksLikeDemoCandidateSet(names: string[]): boolean {
+  const hits = names.filter((name) =>
+    PRODUCT_NAME_DEMO_NAMES.has(name.toLowerCase().replace(/[^a-z0-9]/g, "")),
+  );
+  return hits.length >= 3;
+}
+
+export type ProductNameScreenResultIssue =
+  | "empty_result"
+  | "demo_fallback_result";
+
+export function getProductNameScreenResultIssue(
+  value: unknown,
+): ProductNameScreenResultIssue | null {
+  if (!isRecord(value)) return "empty_result";
+
+  const names = rawScreenCandidates(value)
+    .map(normalizeCandidate)
+    .filter((item): item is ProductNameCandidate => Boolean(item));
+
+  if (names.length === 0) return "empty_result";
+  if (looksLikeDemoCandidateSet(names.map((item) => item.name))) {
+    return "demo_fallback_result";
+  }
+
+  return null;
+}
+
+export function normalizeProductNameScreenResult(
+  value: unknown,
+): ProductNameScreenResult | null {
+  if (!isRecord(value)) return null;
+
+  if (getProductNameScreenResultIssue(value)) return null;
+
+  const rawNames = rawScreenCandidates(value);
+  const names = rawNames
+    .map(normalizeCandidate)
+    .filter((item): item is ProductNameCandidate => Boolean(item));
+
+  if (names.length === 0) return null;
+
+  return {
+    mode: "screen",
+    summary: asString(value.summary, `Generated ${names.length} product name candidates.`),
+    names,
+    progress: Array.isArray(value.progress)
+      ? (value.progress as ProductNameProgressItem[])
+      : [
+          { label: "Received structured result", value: "complete" },
+          { label: "Normalized candidates", value: names.length },
+        ],
+    artifactLinks: isRecord(value.artifactLinks)
+      ? (value.artifactLinks as Record<string, string>)
+      : undefined,
+    disclaimer: asString(
+      value.disclaimer,
+      "Domain and trademark checks are pre-screening only. Confirm details before launch.",
+    ),
+    promptVersion: asString(value.promptVersion, "brand-name-finder-kit.compat"),
+    generatedAt: asString(value.generatedAt, new Date().toISOString()),
+  };
+}
+
+export type ProductNameDetailResultIssue =
+  | "empty_result"
+  | "wrong_mode"
+  | "invalid_detail_result";
+
+export function getProductNameDetailResultIssue(
+  value: unknown,
+): ProductNameDetailResultIssue | null {
+  if (!isRecord(value)) return "empty_result";
+  if (asString(value.mode) && value.mode !== "detail") return "wrong_mode";
+  if (!asString(value.name)) return "invalid_detail_result";
+
+  const seo = value.seo;
+  const trademark = value.trademark;
+  if (!isRecord(seo) || !isRecord(trademark)) return "invalid_detail_result";
+
+  return null;
+}
+
+export function normalizeProductNameDetailResult(
+  value: unknown,
+): ProductNameDetailResult | null {
+  if (getProductNameDetailResultIssue(value)) return null;
+  if (!isRecord(value)) return null;
+
+  const seo = isRecord(value.seo) ? value.seo : {};
+  const trademark = isRecord(value.trademark) ? value.trademark : {};
+
+  return {
+    mode: "detail",
+    name: asString(value.name),
+    summary: asString(value.summary, `Second-stage pre-screen complete for ${value.name}.`),
+    coreIdea: asString(value.coreIdea, ""),
+    recommendation: asString(value.recommendation, ""),
+    domains: normalizeDomains(value.domains),
+    seo: {
+      verdict: normalizeVerdict(seo.verdict),
+      notes: asStringArray(seo.notes),
+      searchLinks: normalizeSearchLinks(seo.searchLinks),
+    },
+    trademark: {
+      verdict: normalizeVerdict(trademark.verdict),
+      notes: asStringArray(trademark.notes),
+      officialSources: normalizeSearchLinks(trademark.officialSources),
+      searchLinks: normalizeSearchLinks(trademark.searchLinks),
+    },
+    risks: asStringArray(value.risks),
+    nextChecks: asStringArray(value.nextChecks),
+    disclaimer: asString(
+      value.disclaimer,
+      "This is a pre-screening result only. Confirm details before launch.",
+    ),
+    promptVersion: asString(value.promptVersion, "brand-name-finder-kit.compat.detail"),
+    generatedAt: asString(value.generatedAt, new Date().toISOString()),
+  };
+}
+
+export function parseCandidateNames(value: string): string[] {
+  return value
+    .split(/[\n,，]/)
+    .map((item) => item.trim())
+    .filter(Boolean)
+    .slice(0, 12);
+}
+
+export function stringifyProductNameScreen(result: ProductNameScreenResult): string {
+  return [
+    result.summary,
+    "",
+    ...result.names.map((item, index) =>
+      [
+        `${index + 1}. ${item.name}`,
+        item.coreIdea,
+        item.basics,
+        item.domains.length
+          ? `Domains: ${item.domains.map((domain) => `${domain.domain} (${domain.status})`).join(", ")}`
+          : "",
+      ]
+        .filter(Boolean)
+        .join("\n"),
+    ),
+    "",
+    result.disclaimer,
+  ].join("\n\n");
+}