@tomako/tools-runtime 0.1.0

package/src/lib/tools/user-interview.schema.ts

@@ -0,0 +1,192 @@
+import { z } from "zod";
+
+export const USER_INTERVIEW_GUIDE_SCENE = "user_interview_guide";
+export const USER_INTERVIEW_GUIDE_RESULT_TYPE = "user_interview_guide";
+export const USER_INTERVIEW_RECORD_SCENE = "user_interview_record";
+export const USER_INTERVIEW_RECORD_RESULT_TYPE = "user_interview_record";
+export const USER_INTERVIEW_INSIGHT_REPORT_SCENE =
+  "user_interview_insight_report";
+export const USER_INTERVIEW_INSIGHT_REPORT_RESULT_TYPE =
+  "user_interview_insight_report";
+
+export const userInterviewProductStageSchema = z.enum([
+  "idea",
+  "mvp",
+  "prototype",
+  "launched",
+  "growth",
+  "churn",
+]);
+
+export const userInterviewGoalSchema = z.enum([
+  "discovery",
+  "problemValidation",
+  "solutionValidation",
+  "usability",
+  "pricing",
+  "churn",
+  "positioning",
+]);
+
+export const userInterviewSessionLengthSchema = z.enum(["30", "45", "60"]);
+
+export const researchBriefSchema = z.object({
+  productName: z.string().trim().min(1),
+  productDescription: z.string().trim().min(1),
+  productStage: userInterviewProductStageSchema,
+  interviewGoal: userInterviewGoalSchema,
+  targetParticipants: z.string().trim().min(1),
+  knownHypotheses: z.string().trim().optional().default(""),
+  decisionToMake: z.string().trim().optional().default(""),
+  hasPrototype: z.boolean().default(false),
+  sessionLength: userInterviewSessionLengthSchema.default("45"),
+  language: z.enum(["zh", "en"]).default("zh"),
+});
+
+export const interviewTranscriptInputSchema = z.object({
+  transcript: z.string().trim().min(1),
+  productContext: z.string().trim().optional().default(""),
+  researchGoal: z.string().trim().optional().default(""),
+  participantContext: z.string().trim().optional().default(""),
+  language: z.enum(["zh", "en"]).default("zh"),
+});
+
+export const interviewInsightInputSchema = z.object({
+  recordsText: z.string().trim().min(1),
+  researchGoal: z.string().trim().optional().default(""),
+  decisionToMake: z.string().trim().optional().default(""),
+  language: z.enum(["zh", "en"]).default("zh"),
+});
+
+export const interviewQuestionSchema = z.object({
+  question: z.string(),
+  purpose: z.string(),
+  listenFor: z.array(z.string()),
+  followUps: z.array(z.string()),
+  avoid: z.string(),
+});
+
+export const sessionFlowItemSchema = z.object({
+  label: z.string(),
+  minutes: z.string(),
+  goal: z.string(),
+});
+
+export const interviewGuideSchema = z.object({
+  recommendedInterviewType: z.string(),
+  researchObjectives: z.array(z.string()),
+  participantCriteria: z.array(z.string()),
+  exclusionCriteria: z.array(z.string()),
+  sessionFlow: z.array(sessionFlowItemSchema),
+  questions: z.array(interviewQuestionSchema),
+  followUpTrees: z.array(
+    z.object({
+      trigger: z.string(),
+      probes: z.array(z.string()),
+    }),
+  ),
+  strongSignals: z.array(z.string()),
+  weakSignals: z.array(z.string()),
+  riskSignals: z.array(z.string()),
+  postInterviewHandoff: z.array(z.string()),
+});
+
+export const userInterviewGuideResultSchema = interviewGuideSchema.extend({
+  currentRead: z
+    .object({
+      product: z.string().optional(),
+      stage: z.string().optional(),
+      interviewGoal: z.string().optional(),
+      coreDecision: z.string().optional(),
+      assumptions: z.array(z.string()).default([]),
+    })
+    .optional(),
+  missingInfo: z.array(z.string()).default([]),
+  reviewChecklist: z.array(z.string()).default([]),
+  promptVersion: z.string().optional(),
+  generatedAt: z.string().optional(),
+});
+
+export const interviewRecordSchema = z.object({
+  participantProfile: z.string(),
+  interviewContext: z.string(),
+  recentBehavior: z.array(z.string()),
+  workflow: z.array(z.string()),
+  painPoints: z.array(
+    z.object({
+      pain: z.string(),
+      evidence: z.string(),
+      cost: z.string(),
+      confidence: z.enum(["high", "medium", "low"]),
+    }),
+  ),
+  alternatives: z.array(z.string()),
+  buyingSignals: z.array(z.string()),
+  quotes: z.array(z.string()),
+  strongSignals: z.array(z.string()),
+  weakSignals: z.array(z.string()),
+  missedFollowUps: z.array(z.string()),
+  openQuestions: z.array(z.string()),
+});
+
+export const userInterviewRecordResultSchema = interviewRecordSchema.extend({
+  missingInfo: z.array(z.string()).default([]),
+  reviewChecklist: z.array(z.string()).default([]),
+  promptVersion: z.string().optional(),
+  generatedAt: z.string().optional(),
+});
+
+export const insightReportSchema = z.object({
+  executiveSummary: z.array(z.string()),
+  participantSegments: z.array(z.string()),
+  themeClusters: z.array(
+    z.object({
+      theme: z.string(),
+      evidence: z.array(z.string()),
+      confidence: z.enum(["high", "medium", "low", "contradictory"]),
+    }),
+  ),
+  painPointRanking: z.array(z.string()),
+  alternativeMap: z.array(z.string()),
+  evidenceStrength: z.array(z.string()),
+  opportunityMap: z.array(z.string()),
+  mvpRecommendation: z.array(z.string()),
+  pricingSignals: z.array(z.string()),
+  messagingSignals: z.array(z.string()),
+  nextExperiments: z.array(z.string()),
+  risksAndUnknowns: z.array(z.string()),
+});
+
+export const userInterviewInsightReportResultSchema = insightReportSchema.extend({
+  missingInfo: z.array(z.string()).default([]),
+  reviewChecklist: z.array(z.string()).default([]),
+  sampleLimitations: z.array(z.string()).default([]),
+  promptVersion: z.string().optional(),
+  generatedAt: z.string().optional(),
+});
+
+export type UserInterviewProductStage = z.infer<
+  typeof userInterviewProductStageSchema
+>;
+export type UserInterviewGoal = z.infer<typeof userInterviewGoalSchema>;
+export type UserInterviewSessionLength = z.infer<
+  typeof userInterviewSessionLengthSchema
+>;
+export type ResearchBrief = z.infer<typeof researchBriefSchema>;
+export type InterviewTranscriptInput = z.infer<
+  typeof interviewTranscriptInputSchema
+>;
+export type InterviewInsightInput = z.infer<typeof interviewInsightInputSchema>;
+export type InterviewQuestion = z.infer<typeof interviewQuestionSchema>;
+export type InterviewGuide = z.infer<typeof interviewGuideSchema>;
+export type UserInterviewGuideResult = z.infer<
+  typeof userInterviewGuideResultSchema
+>;
+export type InterviewRecord = z.infer<typeof interviewRecordSchema>;
+export type UserInterviewRecordResult = z.infer<
+  typeof userInterviewRecordResultSchema
+>;
+export type InsightReport = z.infer<typeof insightReportSchema>;
+export type UserInterviewInsightReportResult = z.infer<
+  typeof userInterviewInsightReportResultSchema
+>;

package/src/lib/zip.ts

@@ -0,0 +1,106 @@
+export type ZipFileInput = {
+  path: string;
+  data: Uint8Array | string;
+};
+
+const CRC32_TABLE = new Uint32Array(
+  Array.from({ length: 256 }, (_, index) => {
+    let crc = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+      crc = crc & 1 ? 0xedb88320 ^ (crc >>> 1) : crc >>> 1;
+    }
+    return crc >>> 0;
+  }),
+);
+
+export function createZipBlob(files: readonly ZipFileInput[]): Blob {
+  const normalizedFiles = files.map((file) => ({
+    path: file.path,
+    data: typeof file.data === "string" ? encodeText(file.data) : file.data,
+  }));
+  const localParts: Uint8Array[] = [];
+  const centralParts: Uint8Array[] = [];
+  let offset = 0;
+  const { dosDate, dosTime } = toDosDateTime(new Date());
+
+  normalizedFiles.forEach((file) => {
+    const name = encodeText(file.path);
+    const crc = crc32(file.data);
+    const localHeader = new Uint8Array(30);
+    const local = new DataView(localHeader.buffer);
+    local.setUint32(0, 0x04034b50, true);
+    local.setUint16(4, 20, true);
+    local.setUint16(6, 0x0800, true);
+    local.setUint16(8, 0, true);
+    local.setUint16(10, dosTime, true);
+    local.setUint16(12, dosDate, true);
+    local.setUint32(14, crc, true);
+    local.setUint32(18, file.data.length, true);
+    local.setUint32(22, file.data.length, true);
+    local.setUint16(26, name.length, true);
+    local.setUint16(28, 0, true);
+    localParts.push(localHeader, name, file.data);
+
+    const centralHeader = new Uint8Array(46);
+    const central = new DataView(centralHeader.buffer);
+    central.setUint32(0, 0x02014b50, true);
+    central.setUint16(4, 20, true);
+    central.setUint16(6, 20, true);
+    central.setUint16(8, 0x0800, true);
+    central.setUint16(10, 0, true);
+    central.setUint16(12, dosTime, true);
+    central.setUint16(14, dosDate, true);
+    central.setUint32(16, crc, true);
+    central.setUint32(20, file.data.length, true);
+    central.setUint32(24, file.data.length, true);
+    central.setUint16(28, name.length, true);
+    central.setUint16(30, 0, true);
+    central.setUint16(32, 0, true);
+    central.setUint16(34, 0, true);
+    central.setUint16(36, 0, true);
+    central.setUint32(38, 0, true);
+    central.setUint32(42, offset, true);
+    centralParts.push(centralHeader, name);
+
+    offset += localHeader.length + name.length + file.data.length;
+  });
+
+  const centralSize = centralParts.reduce((sum, part) => sum + part.length, 0);
+  const end = new Uint8Array(22);
+  const endView = new DataView(end.buffer);
+  endView.setUint32(0, 0x06054b50, true);
+  endView.setUint16(8, normalizedFiles.length, true);
+  endView.setUint16(10, normalizedFiles.length, true);
+  endView.setUint32(12, centralSize, true);
+  endView.setUint32(16, offset, true);
+  endView.setUint16(20, 0, true);
+
+  return new Blob([...localParts, ...centralParts, end].map(toBlobPart), {
+    type: "application/zip",
+  });
+}
+
+function encodeText(value: string): Uint8Array {
+  return new TextEncoder().encode(value);
+}
+
+function toBlobPart(part: Uint8Array): BlobPart {
+  return part.buffer.slice(part.byteOffset, part.byteOffset + part.byteLength) as ArrayBuffer;
+}
+
+function toDosDateTime(date: Date): { dosDate: number; dosTime: number } {
+  const year = Math.max(date.getFullYear(), 1980);
+  const dosDate = ((year - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate();
+  const dosTime = (date.getHours() << 11) | (date.getMinutes() << 5) | Math.floor(date.getSeconds() / 2);
+  return { dosDate, dosTime };
+}
+
+function crc32(data: Uint8Array): number {
+  let crc = 0xffffffff;
+
+  for (const byte of data) {
+    crc = CRC32_TABLE[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+  }
+
+  return (crc ^ 0xffffffff) >>> 0;
+}

package/src/services/tools/handlers/gtm-readiness-checklist.ts

@@ -0,0 +1,71 @@
+import { z } from "zod";
+
+import type { AppLocale } from "../../../i18n/locale";
+import {
+  getGtmChecklistItemKeys,
+  getGtmChecklistItemLabel,
+  getGtmRecommendation,
+  getGtmTierLabel,
+} from "../../../lib/tools/gtm-checklist-copy";
+
+import type { ToolHandler } from "./types";
+
+export { CHECKLIST_ITEMS } from "../../../lib/tools/gtm-checklist-copy";
+
+const checklistKeys = getGtmChecklistItemKeys();
+
+const inputSchema = z.object({
+  answers: z
+    .record(z.string(), z.boolean())
+    .describe("自检项 key → 是否已完成"),
+  locale: z.string().optional().default("zh"),
+});
+
+type Input = z.infer<typeof inputSchema>;
+
+export interface GtmReadinessResult {
+  score: number;
+  total: number;
+  checked: number;
+  tier: "early" | "pilot" | "scale";
+  tierLabel: string;
+  gaps: Array<{ key: string; label: string }>;
+  recommendation: string;
+}
+
+function tierForScore(checked: number): GtmReadinessResult["tier"] {
+  if (checked <= 3) return "early";
+  if (checked <= 6) return "pilot";
+  return "scale";
+}
+
+export const gtmReadinessChecklistHandler: ToolHandler<Input, GtmReadinessResult> = {
+  inputSchema,
+  execute({ answers, locale = "zh" }) {
+    const appLocale = locale as AppLocale;
+    const checked = checklistKeys.filter((key) => answers[key] === true).length;
+    const total = checklistKeys.length;
+    const score = Math.round((checked / total) * 100);
+    const tier = tierForScore(checked);
+    const gaps = checklistKeys
+      .filter((key) => answers[key] !== true)
+      .map((key) => ({
+        key,
+        label: getGtmChecklistItemLabel(key, appLocale),
+      }));
+
+    return {
+      score,
+      total,
+      checked,
+      tier,
+      tierLabel: getGtmTierLabel(tier, appLocale),
+      gaps,
+      recommendation: getGtmRecommendation(tier, appLocale),
+    };
+  },
+};
+
+/** 供 MCP registry 静态导入 */
+export const execute = gtmReadinessChecklistHandler.execute;
+export { inputSchema };

package/src/services/tools/handlers/types.ts

@@ -0,0 +1,7 @@
+import type { z } from "zod";
+
+/** MCP 工具 handler 约定：各工具在 handlers/ 下实现并导出 */
+export interface ToolHandler<TInput = unknown, TOutput = unknown> {
+  inputSchema: z.ZodType<TInput>;
+  execute(input: TInput): Promise<TOutput> | TOutput;
+}