@tomako/tools-runtime 0.1.4 → 0.1.6

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

@@ -118,8 +118,12 @@ const positioningSchema = z
   .default({ strengths: [], weaknesses: [], opportunities: [] });
 
 const sourceSchema = z.object({
-  label: z.string(),
-  url: z.string().optional(),
+  label: z.string().trim().min(1),
+  url: z
+    .string()
+    .trim()
+    .url()
+    .refine((value) => /^https?:\/\//i.test(value), "source url must use http or https"),
 });
 
 export const competitorAnalysisResultSchema = z.object({
@@ -129,14 +133,58 @@ export const competitorAnalysisResultSchema = z.object({
   team: teamSchema,
   funding: fundingSchema,
   positioning: positioningSchema,
-  highlights: z.array(z.string()).default([]),
-  sources: z.array(sourceSchema).default([]),
+  highlights: z.array(z.string().trim().min(1)).default([]),
+  sources: z.array(sourceSchema).min(1),
   confidence,
-  summary: z.string(),
+  summary: z.string().trim().min(1),
   disclaimer: z.string().default(""),
   promptVersion: z.string().default(COMPETITOR_ANALYSIS_PROMPT_VERSION),
   generatedAt: z.string().optional(),
   sourceUrl: z.string().optional(),
+}).superRefine((result, context) => {
+  const hasText = (value: string | undefined) => Boolean(value?.trim());
+  const hasCompetitorIdentity =
+    hasText(result.overview.name) &&
+    [result.overview.description, result.overview.tagline, result.overview.category].some(hasText);
+  if (!hasCompetitorIdentity) {
+    context.addIssue({
+      code: "custom",
+      path: ["overview"],
+      message: "overview must identify the competitor and describe its product or category",
+    });
+  }
+
+  const hasAnalysisFinding =
+    result.highlights.some(hasText) ||
+    [
+      result.traffic.summary,
+      result.traffic.monthlyVisitsEstimate,
+      result.businessScale.summary,
+      result.businessScale.pricingModel,
+      result.team.summary,
+      result.team.teamSize,
+      result.funding.summary,
+      result.funding.totalRaised,
+    ].some(hasText) ||
+    result.traffic.trendSeries.length > 0 ||
+    result.traffic.channels.length > 0 ||
+    result.traffic.geographies.length > 0 ||
+    result.businessScale.customerSegments.length > 0 ||
+    result.businessScale.notableCustomers.length > 0 ||
+    result.team.founders.length > 0 ||
+    result.team.keyPeople.length > 0 ||
+    Boolean(result.funding.lastRound) ||
+    result.funding.investors.length > 0 ||
+    result.positioning.strengths.length > 0 ||
+    result.positioning.weaknesses.length > 0 ||
+    result.positioning.opportunities.length > 0;
+  if (!hasAnalysisFinding) {
+    context.addIssue({
+      code: "custom",
+      path: ["highlights"],
+      message: "result must include at least one concrete analysis finding",
+    });
+  }
 });
 
 export type CompetitorAnalysisResult = z.infer<typeof competitorAnalysisResultSchema>;

package/src/lib/tools/ops-catalog.ts

@@ -47,6 +47,15 @@ export function getEffectiveStatus(
   return getOpsRow(catalog, slug)?.status ?? "draft";
 }
 
+/** Search-index eligibility is stricter than public detail access. */
+export function isToolIndexable(
+  slug: string,
+  catalog: ToolOpsRecord[],
+): boolean {
+  const row = getOpsRow(catalog, slug);
+  return row?.status === "published" && row.showOnIndex;
+}
+
 export async function getEffectiveStatusForSlug(slug: string): Promise<ToolStatus> {
   if (!getToolSpec(slug)) {
     return "draft";
@@ -64,7 +73,7 @@ export async function listIndexedToolSpecs(): Promise<ToolSpec[]> {
   const specsBySlug = new Map(listToolSpecs().map((spec) => [spec.slug, spec]));
 
   return catalog
-    .filter((row) => row.status === "published" && row.showOnIndex)
+    .filter((row) => isToolIndexable(row.slug, catalog))
     .sort(
       (left, right) =>
         left.indexSort - right.indexSort ||