@thanh01.pmt/domain-kit 0.1.0

package/dist/chunk-VFART56O.mjs

@@ -0,0 +1,884 @@
+// src/detector/inputTypeDetector.ts
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".swift",
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".py",
+  ".ino",
+  ".cpp",
+  ".c",
+  ".h",
+  ".hpp",
+  ".kt",
+  ".kts",
+  ".java",
+  ".cs",
+  ".rb",
+  ".go",
+  ".rs",
+  ".php",
+  ".lua",
+  ".r",
+  ".m"
+]);
+var NON_CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".stl",
+  ".obj",
+  ".step",
+  ".stp",
+  ".iges",
+  ".igs",
+  // 3D models
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".svg",
+  ".bmp",
+  // Images
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".pptx",
+  ".xlsx",
+  // Documents
+  ".tc3",
+  ".f3d",
+  // CAD files
+  ".mp3",
+  ".wav",
+  ".midi",
+  // Audio
+  ".mp4",
+  ".avi",
+  ".mov"
+  // Video
+]);
+function detectInputType(options) {
+  const evidence = [];
+  let repoScore = 0;
+  let syllabusScore = 0;
+  let filesScore = 0;
+  let descriptionScore = 0;
+  if (options.repoUrl) {
+    repoScore += 0.5;
+    evidence.push(`repoUrl provided: ${options.repoUrl}`);
+  }
+  if (options.repoDir) {
+    repoScore += 0.5;
+    evidence.push(`repoDir provided: ${options.repoDir}`);
+  }
+  if (options.syllabusText && options.syllabusText.length > 50) {
+    syllabusScore += 0.6;
+    evidence.push(`syllabusText provided (${options.syllabusText.length} chars)`);
+  }
+  if (options.chapters && options.chapters.length > 0) {
+    syllabusScore += 0.4;
+    evidence.push(`${options.chapters.length} chapters provided`);
+  }
+  if (options.fileExtensions && options.fileExtensions.length > 0) {
+    const codeCount = options.fileExtensions.filter((ext) => CODE_EXTENSIONS.has(ext)).length;
+    const nonCodeCount = options.fileExtensions.filter((ext) => NON_CODE_EXTENSIONS.has(ext)).length;
+    if (nonCodeCount > 0) {
+      filesScore += 0.7;
+      evidence.push(`${nonCodeCount} non-code files detected: ${options.fileExtensions.filter((ext) => NON_CODE_EXTENSIONS.has(ext)).join(", ")}`);
+    }
+    if (codeCount > 0 && repoScore === 0) {
+      repoScore += 0.3;
+      evidence.push(`${codeCount} source code files detected`);
+    }
+  }
+  if (options.description && options.description.length > 100) {
+    descriptionScore += 0.5;
+    evidence.push(`description provided (${options.description.length} chars)`);
+  }
+  if (options.goal && options.goal.length > 20) {
+    descriptionScore += 0.3;
+    evidence.push(`goal provided (${options.goal.length} chars)`);
+  }
+  const scores = [
+    { type: "repository", score: repoScore },
+    { type: "syllabus", score: syllabusScore },
+    { type: "files", score: filesScore },
+    { type: "description", score: descriptionScore }
+  ];
+  scores.sort((a, b) => b.score - a.score);
+  const winner = scores[0];
+  const activeTypes = scores.filter((s) => s.score >= 0.3);
+  if (activeTypes.length >= 2) {
+    return {
+      inputType: "mixed",
+      confidence: 0.7,
+      evidence: [...evidence, `Mixed input detected: ${activeTypes.map((t) => t.type).join(" + ")}`]
+    };
+  }
+  if (winner.score === 0) {
+    return {
+      inputType: "description",
+      confidence: 0.3,
+      evidence: [...evidence, "No strong signals \u2014 defaulting to description"]
+    };
+  }
+  return {
+    inputType: winner.type,
+    confidence: Math.min(winner.score, 1),
+    evidence
+  };
+}
+
+// src/detector/domainDetector.ts
+var DOMAIN_KEYWORDS = {
+  software: [
+    "app",
+    "web",
+    "api",
+    "database",
+    "frontend",
+    "backend",
+    "mobile",
+    "swift",
+    "react",
+    "vue",
+    "angular",
+    "node",
+    "python",
+    "java",
+    "typescript",
+    "javascript",
+    "html",
+    "css",
+    "sql",
+    "rest",
+    "graphql",
+    "git",
+    "docker",
+    "kubernetes",
+    "ci/cd",
+    "deploy",
+    "swiftui",
+    "uikit",
+    "flutter",
+    "kotlin",
+    "android",
+    "ios",
+    "nextjs",
+    "nuxt",
+    "svelte",
+    "django",
+    "flask",
+    "express"
+  ],
+  hardware_iot: [
+    "arduino",
+    "robot",
+    "sensor",
+    "motor",
+    "esp32",
+    "gpio",
+    "raspberry pi",
+    "iot",
+    "firmware",
+    "embedded",
+    "microcontroller",
+    "led",
+    "servo",
+    "potentiometer",
+    "breadboard",
+    "soldering",
+    "i2c",
+    "spi",
+    "pwm",
+    "uart",
+    "analog",
+    "digital",
+    "ultrasonic",
+    "infrared",
+    "bluetooth",
+    "wifi module",
+    "pin",
+    "voltage",
+    "resistor",
+    "capacitor",
+    "circuit"
+  ],
+  "3d_design": [
+    "tinkercad",
+    "3d model",
+    "cad",
+    "parametric",
+    "stl",
+    "obj",
+    "fusion360",
+    "blender",
+    "solidworks",
+    "autocad",
+    "freecad",
+    "shape",
+    "dimension",
+    "extrude",
+    "revolve",
+    "fillet",
+    "chamfer",
+    "assembly",
+    "constraint",
+    "sketch",
+    "plane",
+    "axis",
+    "render",
+    "mesh",
+    "nurbs",
+    "surface",
+    "volume"
+  ],
+  math: [
+    // Vietnamese
+    "h\xECnh h\u1ECDc",
+    "\u0111\u1EA1i s\u1ED1",
+    "gi\u1EA3i t\xEDch",
+    "x\xE1c su\u1EA5t",
+    "th\u1ED1ng k\xEA",
+    "tam gi\xE1c",
+    "\u0111\u01B0\u1EDDng tr\xF2n",
+    "ph\u01B0\u01A1ng tr\xECnh",
+    "b\u1EA5t ph\u01B0\u01A1ng tr\xECnh",
+    "s\u1ED1 h\u1ECDc",
+    "t\u1ED5 h\u1EE3p",
+    "ho\xE1n v\u1ECB",
+    "\u0111\u1ED9 \u0111o",
+    "g\xF3c",
+    "c\u1EA1nh",
+    "di\u1EC7n t\xEDch",
+    "th\u1EC3 t\xEDch",
+    "chu vi",
+    "\u0111\u01B0\u1EDDng cao",
+    "trung tuy\u1EBFn",
+    // English
+    "geometry",
+    "algebra",
+    "calculus",
+    "trigonometry",
+    "logarithm",
+    "probability",
+    "statistics",
+    "derivative",
+    "integral",
+    "matrix",
+    "vector",
+    "theorem",
+    "proof",
+    "angle",
+    "perimeter",
+    "area",
+    // Chinese
+    "\u51E0\u4F55",
+    "\u4EE3\u6570",
+    "\u5FAE\u79EF\u5206",
+    "\u6982\u7387",
+    "\u7EDF\u8BA1",
+    "\u4E09\u89D2\u5F62",
+    "\u5706",
+    "\u65B9\u7A0B",
+    // Japanese
+    "\u5E7E\u4F55",
+    "\u4EE3\u6570",
+    "\u5FAE\u5206",
+    "\u7A4D\u5206",
+    "\u78BA\u7387",
+    "\u7D71\u8A08",
+    // French
+    "g\xE9om\xE9trie",
+    "alg\xE8bre",
+    "calcul",
+    "trigonom\xE9trie",
+    "probabilit\xE9"
+  ],
+  science: [
+    // Vietnamese
+    "l\xFD thuy\u1EBFt",
+    "nguy\xEAn l\xFD",
+    "th\xED nghi\u1EC7m",
+    "\u0111i\u1EC7n",
+    "l\u1EF1c",
+    "h\xF3a h\u1ECDc",
+    "sinh h\u1ECDc",
+    "v\u1EADt l\xFD",
+    "\u0111\u1ECBa l\xFD",
+    "ph\u1EA3n \u1EE9ng",
+    "nguy\xEAn t\u1ED1",
+    "ph\xE2n t\u1EED",
+    "n\u0103ng l\u01B0\u1EE3ng",
+    "c\u1EA3m \u1EE9ng",
+    "t\u1EEB tr\u01B0\u1EDDng",
+    "quang h\u1ECDc",
+    "m\xF4i tr\u01B0\u1EDDng",
+    "sinh th\xE1i",
+    // English
+    "physics",
+    "chemistry",
+    "biology",
+    "earth science",
+    "cell",
+    "gene",
+    "evolution",
+    "ecosystem",
+    "molecule",
+    "atom",
+    // Chinese
+    "\u7269\u7406",
+    "\u5316\u5B66",
+    "\u751F\u7269",
+    "\u5730\u7406",
+    // Japanese
+    "\u7269\u7406",
+    "\u5316\u5B66",
+    "\u751F\u7269",
+    // French
+    "physique",
+    "chimie",
+    "biologie"
+  ],
+  language: [
+    // Vietnamese
+    "ti\u1EBFng anh",
+    "ti\u1EBFng vi\u1EC7t",
+    "ng\u1EEF ph\xE1p",
+    "t\u1EEB v\u1EF1ng",
+    "\u0111\u1ECDc",
+    "vi\u1EBFt",
+    "n\xF3i",
+    "nghe",
+    // English
+    "grammar",
+    "vocabulary",
+    "writing",
+    "reading",
+    "speaking",
+    "listening",
+    "pronunciation",
+    "essay",
+    "paragraph",
+    "sentence",
+    "verb",
+    "noun",
+    "adjective",
+    "ielts",
+    "toeic",
+    "toefl",
+    // Chinese
+    "\u82F1\u8BED",
+    "\u8BED\u6CD5",
+    "\u8BCD\u6C47",
+    "\u9605\u8BFB",
+    "\u5199\u4F5C",
+    // Japanese
+    "\u82F1\u8A9E",
+    "\u6587\u6CD5",
+    "\u8A9E\u5F59",
+    "\u8AAD\u89E3",
+    "\u4F5C\u6587",
+    // French
+    "anglais",
+    "grammaire",
+    "vocabulaire",
+    "lecture",
+    "\xE9criture"
+  ],
+  arts: [
+    // Vietnamese
+    "\xE2m nh\u1EA1c",
+    "nh\u1EA1c l\xFD",
+    "solf\xE8ge",
+    "\u0111\xE0n",
+    "piano",
+    "guitar",
+    "h\u1ED9i h\u1ECDa",
+    "thi\u1EBFt k\u1EBF",
+    "nhi\u1EBFp \u1EA3nh",
+    "tranh",
+    "m\xE0u",
+    "s\xE1ng t\xE1c",
+    "bi\xEAn kh\xFAc",
+    // English
+    "music",
+    "art",
+    "painting",
+    "drawing",
+    "sketch",
+    "photography",
+    "color theory",
+    "composition",
+    "typography",
+    "layout",
+    "digital art",
+    "illustration",
+    "figma",
+    // Chinese
+    "\u97F3\u4E50",
+    "\u7F8E\u672F",
+    "\u7ED8\u753B",
+    "\u6444\u5F71",
+    "\u8BBE\u8BA1",
+    // Japanese
+    "\u97F3\u697D",
+    "\u7F8E\u8853",
+    "\u7D75\u753B",
+    "\u5199\u771F",
+    "\u30C7\u30B6\u30A4\u30F3",
+    // French
+    "musique",
+    "art",
+    "peinture",
+    "dessin",
+    "photographie"
+  ],
+  research: [
+    // Vietnamese
+    "nghi\xEAn c\u1EE9u",
+    "th\u1ED1ng k\xEA",
+    "ph\u01B0\u01A1ng ph\xE1p lu\u1EADn",
+    "ph\xE2n t\xEDch d\u1EEF li\u1EC7u",
+    "\u0111\u1ECBnh t\xEDnh",
+    "\u0111\u1ECBnh l\u01B0\u1EE3ng",
+    "gi\u1EA3 thuy\u1EBFt",
+    "m\u1EABu",
+    "t\u1ED5ng th\u1EC3",
+    "t\u01B0\u01A1ng quan",
+    "h\u1ED3i quy",
+    "t\xE0i li\u1EC7u tham kh\u1EA3o",
+    "tr\xEDch d\u1EABn",
+    "t\xF3m t\u1EAFt",
+    // English
+    "research",
+    "survey",
+    "methodology",
+    "data analysis",
+    "qualitative",
+    "quantitative",
+    "hypothesis",
+    "experiment",
+    "sample",
+    "population",
+    "correlation",
+    "regression",
+    "literature review",
+    "citation",
+    "abstract",
+    // Chinese
+    "\u7814\u7A76",
+    "\u8C03\u67E5",
+    "\u65B9\u6CD5\u8BBA",
+    "\u6570\u636E\u5206\u6790",
+    // Japanese
+    "\u7814\u7A76",
+    "\u8ABF\u67FB",
+    "\u65B9\u6CD5\u8AD6",
+    "\u30C7\u30FC\u30BF\u5206\u6790",
+    // French
+    "recherche",
+    "enqu\xEAte",
+    "m\xE9thodologie",
+    "analyse de donn\xE9es"
+  ],
+  business: [
+    // Vietnamese
+    "kinh doanh",
+    "t\xE0i ch\xEDnh",
+    "qu\u1EA3n l\xFD",
+    "marketing",
+    "b\xE1n h\xE0ng",
+    "kh\u1EDFi nghi\u1EC7p",
+    "k\u1EBF ho\u1EA1ch kinh doanh",
+    "doanh thu",
+    "l\u1EE3i nhu\u1EADn",
+    "qu\u1EA3n tr\u1ECB",
+    "t\xE0i kho\u1EA3n",
+    "\u0111\u1EA7u t\u01B0",
+    "ng\xE2n s\xE1ch",
+    // English
+    "business",
+    "finance",
+    "accounting",
+    "investment",
+    "budget",
+    "startup",
+    "revenue",
+    "profit",
+    "roi",
+    "sales",
+    "product management",
+    "agile",
+    "scrum",
+    "kanban",
+    // Chinese
+    "\u5546\u4E1A",
+    "\u91D1\u878D",
+    "\u4F1A\u8BA1",
+    "\u6295\u8D44",
+    "\u8425\u9500",
+    // Japanese
+    "\u30D3\u30B8\u30CD\u30B9",
+    "\u91D1\u878D",
+    "\u4F1A\u8A08",
+    "\u6295\u8CC7",
+    "\u30DE\u30FC\u30B1\u30C6\u30A3\u30F3\u30B0",
+    // French
+    "affaires",
+    "finance",
+    "comptabilit\xE9",
+    "investissement"
+  ],
+  other: []
+};
+var EXTENSION_DOMAIN = {
+  ".swift": "software",
+  ".ts": "software",
+  ".tsx": "software",
+  ".js": "software",
+  ".jsx": "software",
+  ".py": "software",
+  ".kt": "software",
+  ".kts": "software",
+  ".java": "software",
+  ".cs": "software",
+  ".go": "software",
+  ".rs": "software",
+  ".rb": "software",
+  ".php": "software",
+  ".lua": "software",
+  ".r": "software",
+  // .ino is ALWAYS hardware
+  ".ino": "hardware_iot",
+  // .cpp/.c/.h are CONTEXT-DEPENDENT → resolve in detection logic
+  ".stl": "3d_design",
+  ".obj": "3d_design",
+  ".step": "3d_design",
+  ".stp": "3d_design",
+  ".tc3": "3d_design",
+  ".f3d": "3d_design"
+};
+var AMBIGUOUS_EXTENSIONS = /* @__PURE__ */ new Set([".cpp", ".c", ".h", ".hpp"]);
+var LANG_PATTERNS = [
+  { lang: "vi", patterns: [/[ạảãàáạảãạ]/i, /\bgiải\b/, /\btính\b/] },
+  { lang: "zh", patterns: [/[\u4e00-\u9fff]{2,}/] },
+  { lang: "ja", patterns: [/[\u3040-\u309f\u30a0-\u30ff]{2,}/] },
+  { lang: "ko", patterns: [/[\uac00-\ud7af]{2,}/] },
+  { lang: "fr", patterns: [/\b(la|le|les|des|une|est|sont|avec|pour|dans)\b/i] }
+];
+function detectSyllabusLanguage(text) {
+  for (const { lang, patterns } of LANG_PATTERNS) {
+    if (patterns.some((p) => p.test(text))) return lang;
+  }
+  return "en";
+}
+function detectDomain(options) {
+  const evidence = [];
+  const detectedTechStack = [];
+  let detectedSubject = "";
+  let ambiguous;
+  const scores = {
+    software: 0,
+    hardware_iot: 0,
+    "3d_design": 0,
+    math: 0,
+    science: 0,
+    language: 0,
+    arts: 0,
+    research: 0,
+    business: 0,
+    other: 0
+  };
+  const hasHardwareContext = !!(options.techStack?.toLowerCase().match(/arduino|esp32|raspberry|embedded|iot/) || options.description?.toLowerCase().match(/arduino|robot|sensor|motor|circuit/) || options.goal?.toLowerCase().match(/arduino|robot|sensor|motor|circuit/));
+  const hasSoftwareContext = !!(options.techStack?.toLowerCase().match(/swift|react|vue|angular|python|java|typescript|javascript/) || options.description?.toLowerCase().match(/app|web|api|frontend|backend|mobile/) || options.goal?.toLowerCase().match(/app|web|api|frontend|backend|mobile/));
+  if (options.fileExtensions) {
+    for (const ext of options.fileExtensions) {
+      const extLower = ext.toLowerCase();
+      if (extLower === ".ino") {
+        scores.hardware_iot += 0.5;
+        evidence.push(`File extension ${ext} \u2192 hardware_iot (always)`);
+        continue;
+      }
+      if (AMBIGUOUS_EXTENSIONS.has(extLower)) {
+        if (hasHardwareContext && !hasSoftwareContext) {
+          scores.hardware_iot += 0.3;
+          evidence.push(`File extension ${ext} \u2192 hardware_iot (hardware context)`);
+        } else if (hasSoftwareContext && !hasHardwareContext) {
+          scores.software += 0.3;
+          evidence.push(`File extension ${ext} \u2192 software (software context)`);
+        } else if (hasHardwareContext && hasSoftwareContext) {
+          scores.software += 0.15;
+          scores.hardware_iot += 0.15;
+          evidence.push(`File extension ${ext} \u2192 ambiguous (both software and hardware context)`);
+          ambiguous = {
+            domain1: "software",
+            domain2: "hardware_iot",
+            reason: `.cpp/.c/.h files present with both software and hardware context keywords`
+          };
+        } else {
+          scores.software += 0.2;
+          evidence.push(`File extension ${ext} \u2192 software (default, no context)`);
+        }
+        continue;
+      }
+      const domain = EXTENSION_DOMAIN[extLower];
+      if (domain) {
+        scores[domain] += 0.3;
+        evidence.push(`File extension ${ext} \u2192 ${domain}`);
+      }
+    }
+  }
+  const textContent = [
+    options.description || "",
+    options.goal || "",
+    options.syllabusText || ""
+  ].join(" ").toLowerCase();
+  for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORDS)) {
+    const cat = domain;
+    for (const kw of keywords) {
+      if (textContent.includes(kw.toLowerCase())) {
+        scores[cat] += 0.1;
+        if (!evidence.some((e) => e.includes(`"${kw}"`))) {
+          evidence.push(`Keyword "${kw}" \u2192 ${cat}`);
+        }
+      }
+    }
+  }
+  if (options.techStack) {
+    const techItems = options.techStack.split(",").map((t) => t.trim());
+    for (const tech of techItems) {
+      const techL = tech.toLowerCase();
+      if (["swift", "swiftui", "uikit", "ios"].some((k) => techL.includes(k))) {
+        scores.software += 0.4;
+        detectedTechStack.push(tech);
+      } else if (["react", "vue", "angular", "next", "nuxt", "typescript", "javascript"].some((k) => techL.includes(k))) {
+        scores.software += 0.4;
+        detectedTechStack.push(tech);
+      } else if (["python", "django", "flask"].some((k) => techL.includes(k))) {
+        scores.software += 0.3;
+        detectedTechStack.push(tech);
+      } else if (["arduino", "esp32", "raspberry"].some((k) => techL.includes(k))) {
+        scores.hardware_iot += 0.5;
+        detectedTechStack.push(tech);
+      } else if (["tinkercad", "fusion360", "blender"].some((k) => techL.includes(k))) {
+        scores["3d_design"] += 0.5;
+        detectedTechStack.push(tech);
+      } else if (["c++", "c", "cpp"].some((k) => techL === k || techL.endsWith(k))) {
+        if (hasHardwareContext) {
+          scores.hardware_iot += 0.3;
+        } else {
+          scores.software += 0.3;
+        }
+        detectedTechStack.push(tech);
+      }
+    }
+  }
+  if (options.syllabusText) {
+    const syllabusLang = detectSyllabusLanguage(options.syllabusText);
+    const syllabusLower = options.syllabusText.toLowerCase();
+    if (syllabusLower.includes("h\xECnh h\u1ECDc") || syllabusLower.includes("\u0111\u1EA1i s\u1ED1") || syllabusLower.includes("geometry") || syllabusLower.includes("algebra") || syllabusLower.includes("\u51E0\u4F55") || syllabusLower.includes("\u4EE3\u6570") || syllabusLower.includes("\u5E7E\u4F55") || syllabusLower.includes("\u4EE3\u6570") || syllabusLower.includes("g\xE9om\xE9trie") || syllabusLower.includes("alg\xE8bre")) {
+      scores.math += 0.5;
+      detectedSubject = "Mathematics";
+    } else if (syllabusLower.includes("v\u1EADt l\xFD") || syllabusLower.includes("h\xF3a") || syllabusLower.includes("sinh") || syllabusLower.includes("physics") || syllabusLower.includes("chemistry") || syllabusLower.includes("biology") || syllabusLower.includes("\u7269\u7406") || syllabusLower.includes("\u5316\u5B66") || syllabusLower.includes("\u7269\u7406") || syllabusLower.includes("\u5316\u5B66") || syllabusLower.includes("physique") || syllabusLower.includes("chimie")) {
+      scores.science += 0.5;
+      detectedSubject = "Natural Science";
+    } else if (syllabusLower.includes("ti\u1EBFng anh") || syllabusLower.includes("english") || syllabusLower.includes("grammar") || syllabusLower.includes("\u82F1\u8BED") || syllabusLower.includes("\u82F1\u8A9E") || syllabusLower.includes("anglais")) {
+      scores.language += 0.5;
+      detectedSubject = "English Language";
+    }
+    evidence.push(`Syllabus language detected: ${syllabusLang}`);
+  }
+  const entries = Object.entries(scores).filter(([k]) => k !== "other");
+  entries.sort((a, b) => b[1] - a[1]);
+  const [winner, winnerScore] = entries[0];
+  if (winnerScore === 0) {
+    return {
+      domainCategory: "other",
+      confidence: 0.2,
+      evidence: [...evidence, "No domain signals detected"],
+      detectedTechStack,
+      detectedSubject
+    };
+  }
+  const second = entries[1];
+  if (second && winnerScore - second[1] < 0.15 && winnerScore > 0) {
+    ambiguous = {
+      domain1: winner,
+      domain2: second[0],
+      reason: `Scores very close: ${winner}=${winnerScore.toFixed(2)}, ${second[0]}=${second[1].toFixed(2)}`
+    };
+  }
+  const totalScore = entries.reduce((sum, [, s]) => sum + s, 0);
+  const confidence = totalScore > 0 ? Math.min(winnerScore / totalScore + 0.3, 1) : 0.3;
+  return {
+    domainCategory: winner,
+    confidence,
+    evidence: evidence.slice(0, 20),
+    detectedTechStack,
+    detectedSubject,
+    ambiguous
+  };
+}
+
+// src/detector/learningModeDetector.ts
+var BUILD_VERBS = [
+  "build",
+  "create",
+  "develop",
+  "implement",
+  "construct",
+  "make",
+  "x\xE2y d\u1EF1ng",
+  "t\u1EA1o",
+  "ph\xE1t tri\u1EC3n",
+  "tri\u1EC3n khai",
+  "l\u1EAFp r\xE1p",
+  "code",
+  "program",
+  "design a",
+  "set up",
+  "deploy"
+];
+var UNDERSTAND_VERBS = [
+  "understand",
+  "learn",
+  "grasp",
+  "comprehend",
+  "master",
+  "hi\u1EC3u",
+  "n\u1EAFm v\u1EEFng",
+  "h\u1ECDc",
+  "ti\u1EBFp thu",
+  "am hi\u1EC3u",
+  "v\u1EADn d\u1EE5ng",
+  "ph\xE2n t\xEDch",
+  "\u0111\xE1nh gi\xE1",
+  "so s\xE1nh",
+  "explain",
+  "describe",
+  "analyze",
+  "evaluate",
+  "compare"
+];
+var CONCEPT_DOMAINS = ["math", "science", "language", "arts", "research", "business"];
+var PRODUCT_DOMAINS = ["software", "hardware_iot", "3d_design"];
+function detectLearningMode(options) {
+  const evidence = [];
+  const text = [options.goal || "", options.description || ""].join(" ").toLowerCase();
+  let productScore = 0;
+  let conceptScore = 0;
+  if (options.hasRepo) {
+    productScore += 0.3;
+    evidence.push("Repository present \u2192 product signal");
+  }
+  if (options.hasSyllabus) {
+    conceptScore += 0.3;
+    evidence.push("Syllabus present \u2192 concept signal");
+  }
+  if (PRODUCT_DOMAINS.includes(options.domainCategory)) {
+    productScore += 0.2;
+    evidence.push(`Domain ${options.domainCategory} \u2192 product\u503E\u5411`);
+  }
+  if (CONCEPT_DOMAINS.includes(options.domainCategory)) {
+    conceptScore += 0.2;
+    evidence.push(`Domain ${options.domainCategory} \u2192 concept\u503E\u5411`);
+  }
+  const hasBuildVerbs = BUILD_VERBS.some((v) => text.includes(v));
+  const hasUnderstandVerbs = UNDERSTAND_VERBS.some((v) => text.includes(v));
+  if (hasBuildVerbs) {
+    productScore += 0.3;
+    evidence.push("Build verbs detected in goal/description");
+  }
+  if (hasUnderstandVerbs) {
+    conceptScore += 0.3;
+    evidence.push("Understand verbs detected in goal/description");
+  }
+  const total = productScore + conceptScore;
+  if (total === 0) {
+    return {
+      learningMode: "product",
+      confidence: 0.3,
+      evidence: [...evidence, "No signals \u2014 defaulting to product"]
+    };
+  }
+  if (productScore >= 0.3 && conceptScore >= 0.3) {
+    const hybridConf = Math.min((productScore + conceptScore) / 2, 1);
+    return {
+      learningMode: "hybrid",
+      confidence: hybridConf,
+      evidence: [...evidence, `Mixed signals: product=${productScore.toFixed(2)}, concept=${conceptScore.toFixed(2)} \u2192 hybrid`]
+    };
+  }
+  if (productScore > conceptScore) {
+    const raw2 = total > 0 ? productScore / total : 0.5;
+    return {
+      learningMode: "product",
+      confidence: Math.min(Math.max(raw2, 0) + 0.2, 1),
+      evidence
+    };
+  }
+  const raw = total > 0 ? conceptScore / total : 0.5;
+  return {
+    learningMode: "concept",
+    confidence: Math.min(Math.max(raw, 0) + 0.2, 1),
+    evidence
+  };
+}
+
+// src/detector/domainProfileDetector.ts
+function detectDomainProfile(options) {
+  const inputResult = detectInputType(options);
+  const domainResult = detectDomain({
+    description: options.description,
+    goal: options.goal,
+    syllabusText: options.syllabusText,
+    techStack: options.techStack,
+    fileExtensions: options.fileExtensions,
+    repoUrl: options.repoUrl
+  });
+  const modeResult = detectLearningMode({
+    inputType: inputResult.inputType,
+    domainCategory: domainResult.domainCategory,
+    goal: options.goal,
+    description: options.description,
+    hasRepo: !!(options.repoUrl || options.repoDir),
+    hasSyllabus: !!(options.syllabusText || options.chapters && options.chapters.length > 0)
+  });
+  const graphType = determineGraphType(modeResult.learningMode);
+  return {
+    inputType: inputResult.inputType,
+    domainCategory: domainResult.domainCategory,
+    learningMode: modeResult.learningMode,
+    graphType,
+    confidence: {
+      inputType: inputResult.confidence,
+      domainCategory: domainResult.confidence,
+      learningMode: modeResult.confidence
+    },
+    evidence: [...inputResult.evidence, ...domainResult.evidence, ...modeResult.evidence],
+    detectedTechStack: domainResult.detectedTechStack,
+    detectedSubject: domainResult.detectedSubject,
+    detectedDomain: domainResult.domainCategory,
+    goal: options.goal || "",
+    description: options.description || "",
+    repoUrl: options.repoUrl || "",
+    repoDir: options.repoDir || "",
+    syllabusText: options.syllabusText || ""
+  };
+}
+function determineGraphType(learningMode) {
+  switch (learningMode) {
+    case "product":
+      return "project_graph";
+    case "concept":
+      return "knowledge_graph";
+    case "hybrid":
+      return "hybrid_graph";
+    default:
+      return "project_graph";
+  }
+}
+
+export { detectDomain, detectDomainProfile, detectInputType, detectLearningMode };
+//# sourceMappingURL=chunk-VFART56O.mjs.map
+//# sourceMappingURL=chunk-VFART56O.mjs.map