Files
community/knowledge/cad-parts/evals/archive/reader-contract-before-v5/CadAiKnowledge.java.txt
T
2026-11-12 20:40:21 +08:00

712 lines
50 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package com.linkerbot.vibemake.service.cad.ai;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.linkerbot.vibemake.service.config.CadAiProperties;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/** Read-only, versioned CAD recipe routing. It never infers dimensions from prose. */
@Component
public class CadAiKnowledge {
public static final String PROTOCOL = "cad-knowledge-v1";
public static final String INSTRUCTIONS = "沿原通用技能建模。当前已明确的齿轮、齿条、蜗轮蜗杆及其机构,按需用knowledge_lookup读取已有专项构造规程;XZ草图造轴承座筋时可查询方向风险提示。普通板、轴、螺栓、座体、壳体无需查。仅补齐已明确条件后重查,不改需求凑命中;无适用内容沿原流程,有效上下文已有正文不重复读。用户要求优先于选配示例。";
private static final Logger log = LoggerFactory.getLogger(CadAiKnowledge.class);
private static final String RESOURCE_ROOT = "cad/ai/knowledge/";
private static final Set<String> SPUR_CONDITIONS = Set.of("module_mm", "teeth", "pressure_angle_deg", "profile_shift", "backlash_mm", "addendum_coefficient", "clearance_coefficient", "root_transition");
private static final List<Pattern> QUALIFIED_GEAR_NAMES = List.of(
Pattern.compile("(?:(?:内啮合|外啮合|内齿|外齿|内|外|渐开线|直齿|斜齿|螺旋|圆柱|环形|锥齿|圆锥)(?:的\\s*)?\\s*)+(?:齿轮|齿圈|轮)"),
Pattern.compile("\\b(?:(?:internal|external|involute|spur|helical|bevel|cylindrical|ring)\\s+)+gears?\\b"));
private static final Pattern UNCERTAIN_NEGATION = Pattern.compile("(?:不能|不得|不可|不允许|不准|不许|不应|不要|不是|并非|禁止|严禁|切勿|请勿|勿|避免|不生成|不创建|不制作|不建)\\s*(?:不|没有|禁止|避免|无\\s*(?:中央|中心)?(?:退刀槽|槽)(?=\\s*(?:[,,。;;\\n]|$)))|\\b(?:not|never|without)\\s+(?:not|no|without|avoid(?:ing)?|excluding|fail\\s+to)\\b");
private static final Pattern REFERENCE_CREATION = Pattern.compile("(?s).*(?:生成|制作|创建|构造|绘制|建模|只造|只做|做|造|建|画|当前待修改部件是|\\bmake|\\bcreate|\\bbuild|\\bmodel|\\bgenerate|\\bdraw)\\s*(?:一个|一件|一套|一只|一条|a\\b|an\\b|the\\b)?\\s*$");
private static final Pattern TARGET_INTENT = Pattern.compile("生成|制作|创建|构造|绘制|建模|只造|只做|修改|只查询|只查|当前待(?:建|修改)部件是|\\b(?:make|create|build|model|generate|draw|modify)\\b");
private static final Pattern JOINED_TARGET = Pattern.compile("(?s).*(?:和|与|及|以及|并|同时|另|再|\\band|\\balso)\\s*$");
private static final Pattern SHAFT_INTERFACE = Pattern.compile("齿轮(?:安装)?孔(?=\\s*(?:名义)?(?:直径|孔径|尺寸|为|=|[::])?\\s*\\d)");
private static final String REFERENCE_MODIFIERS = "(?:(?![,,。;;\\r\\n]|生成|制作|创建|构造|绘制|建模|修改|另|再|并|和|与|以及|\\b(?:create|build|generate|make|modify|and|also)\\b).){0,128}?";
private final ObjectMapper json;
private final CadAiProperties properties;
private final Map<String, JsonNode> types;
private final Map<String, JsonNode> factDefinitions;
private final List<Recipe> recipes;
private final Pattern referenceNames;
private final Pattern companionNames;
private record Recipe(JsonNode metadata, String text) {}
private record QualifiedGearName(String name, String type, int start, int end, boolean conflict) {}
@Autowired
public CadAiKnowledge(ObjectMapper json, CadAiProperties properties) throws IOException {
this(json, properties, readPolicy(json));
}
// Explicit policy keeps historical routing fixtures reproducible after utility withdrawals.
CadAiKnowledge(ObjectMapper json, CadAiProperties properties, JsonNode policy) throws IOException {
this.json = json;
this.properties = properties;
JsonNode catalog = read("generation/catalog.json");
types = validateCatalog(catalog);
referenceNames = referenceNames(types);
companionNames = Pattern.compile("(?:配套|匹配)" + REFERENCE_MODIFIERS + objectNames(types)
+ "(?=\\s*(?:的\\s*)?(?:中心距|轴向模数|法向模数|端面模数|模数|轴向压力角|压力角|分度(?:圆)?(?:直径|径)|孔径|轴径|安装孔|中心高|接口|配合))");
factDefinitions = validateFactDefinitions(catalog);
recipes = validateRecipes(policy);
log.info("CAD knowledge loaded: version={}, types={}, recipes={}", catalog.path("version").asText(), types.size(), recipes.size());
}
private static JsonNode readPolicy(ObjectMapper json) throws IOException {
try (InputStream input = new ClassPathResource(RESOURCE_ROOT + "generation/policy.json").getInputStream()) {
return json.readTree(input);
}
}
private JsonNode read(String path) throws IOException {
try (InputStream input = new ClassPathResource(RESOURCE_ROOT + path).getInputStream()) {
return json.readTree(input);
}
}
static Map<String, JsonNode> validateCatalog(JsonNode catalog) throws IOException {
if (catalog == null || catalog.path("schema_version").asInt() != 1 || !catalog.path("types").isArray())
throw new IOException("Invalid CAD knowledge catalog");
Map<String, JsonNode> index = new LinkedHashMap<>();
Set<String> registeredAliases = new HashSet<>();
for (JsonNode type : catalog.path("types")) {
String id = type.path("id").asText();
if (!id.matches("[a-z][a-z0-9-]{1,79}") || index.put(id, type) != null
|| type.path("name_zh").asText().isBlank() || !type.path("aliases").isArray()
|| !Set.of("group", "part", "mechanism").contains(type.path("kind").asText()))
throw new IOException("Invalid or duplicate CAD knowledge type");
Set<String> aliases = new HashSet<>();
for (JsonNode alias : type.path("aliases"))
if (!alias.isTextual() || alias.asText().isBlank() || !aliases.add(alias.asText()) || !registeredAliases.add(alias.asText().toLowerCase(Locale.ROOT)))
throw new IOException("Invalid CAD knowledge alias");
}
for (String id : index.keySet()) {
Set<String> visited = new HashSet<>();
String cursor = id;
while (cursor != null) {
if (!visited.add(cursor) || !index.containsKey(cursor)) throw new IOException("Broken or cyclic CAD knowledge hierarchy");
JsonNode parent = index.get(cursor).get("parent");
cursor = parent == null || parent.isNull() ? null : parent.asText();
}
for (JsonNode related : index.get(id).path("related_types"))
if (!index.containsKey(related.asText())) throw new IOException("Broken CAD knowledge type reference");
}
if (index.isEmpty()) throw new IOException("Empty CAD knowledge catalog");
return Map.copyOf(index);
}
/** Canonical property dictionary shared by tool schemas and recipe eligibility. */
static Map<String, JsonNode> validateFactDefinitions(JsonNode catalog) throws IOException {
JsonNode definitions = catalog.path("fact_definitions");
if (!definitions.isObject() || definitions.isEmpty() || definitions.size() > 64)
throw new IOException("Invalid CAD knowledge property dictionary");
Map<String, JsonNode> result = new TreeMap<>();
Iterator<Map.Entry<String, JsonNode>> entries = definitions.fields();
while (entries.hasNext()) {
Map.Entry<String, JsonNode> entry = entries.next();
JsonNode definition = entry.getValue();
if (!entry.getKey().matches("[a-z][a-z0-9_]{0,63}") || !definition.isObject()
|| !Set.of("number", "string", "boolean").contains(definition.path("type").asText())
|| !Set.of("mm", "deg", "count", "none").contains(definition.path("unit").asText())
|| !definition.path("description").isTextual() || definition.path("description").asText().isBlank()
|| definition.path("description").asText().length() > 160)
throw new IOException("Invalid CAD knowledge property definition");
result.put(entry.getKey(), definition);
}
return Collections.unmodifiableMap(result);
}
private List<Recipe> validateRecipes(JsonNode policy) throws IOException {
if (policy == null || policy.path("schema_version").asInt() != 1 || !policy.path("documents").isArray())
throw new IOException("Invalid CAD knowledge policy");
Set<String> ids = new HashSet<>();
List<Recipe> result = new ArrayList<>();
for (JsonNode document : policy.path("documents")) {
String id = document.path("doc_id").asText();
String path = document.path("path").asText();
String hash = document.path("sha256").asText();
if (!id.matches("[a-z][a-z0-9-]+") || !ids.add(id)
|| !document.path("version").asText().matches("\\d+\\.\\d+\\.\\d+")
|| !Set.of("retired", "experimental", "approved").contains(document.path("status").asText())
|| !path.matches("generation/(candidates|archive)/[a-z0-9-]+\\.md")
|| !hash.matches("[a-f0-9]{64}")) throw new IOException("Invalid CAD knowledge recipe metadata");
validatePublication(document);
byte[] bytes;
try (InputStream input = new ClassPathResource(RESOURCE_ROOT + path).getInputStream()) { bytes = input.readAllBytes(); }
verifyHash(bytes, hash);
if (bytes.length == 0 || bytes.length > 24 * 1024) throw new IOException("CAD knowledge recipe body exceeds transport budget");
if ("retired".equals(document.path("status").asText())) continue;
String role = document.path("content_role").asText("recipe");
if (!Set.of("recipe", "risk_hint").contains(role)) throw new IOException("Invalid CAD knowledge content role");
validateActivation(document.path("activation"));
if (!types.containsKey(document.path("type_id").asText()) || !document.path("conditions").isObject()
|| document.path("conditions").isEmpty() && !("risk_hint".equals(role) && document.has("activation")))
throw new IOException("Incomplete CAD knowledge recipe eligibility");
if (!document.path("conditions").isEmpty())
validateConditions(document.path("type_id").asText(), document.path("conditions"), factDefinitions);
result.add(new Recipe(document, new String(bytes, StandardCharsets.UTF_8)));
}
return List.copyOf(result);
}
private static void validateActivation(JsonNode activation) throws IOException {
if (activation.isMissingNode()) return;
if (!activation.isObject() || activation.size() != 2)
throw new IOException("Invalid CAD knowledge activation");
for (String field : List.of("all_terms", "any_terms")) {
JsonNode terms = activation.path(field);
if (!terms.isArray() || terms.isEmpty() || terms.size() > 8)
throw new IOException("Invalid CAD knowledge activation terms");
Set<String> unique = new HashSet<>();
for (JsonNode term : terms)
if (!term.isTextual() || term.asText().isBlank() || term.asText().length() > 40
|| !term.asText().equals(term.asText().strip().toLowerCase(Locale.ROOT)) || !unique.add(term.asText()))
throw new IOException("Invalid CAD knowledge activation term");
}
}
private static boolean activationMatches(JsonNode activation, String query) {
if (activation.isMissingNode()) return true;
// Keep operation terms together: a housing name containing 筋 must not activate an XZ bore operation.
for (String clause : query.split("[,,。;;\\n]")) {
boolean all = true;
for (JsonNode term : activation.path("all_terms")) if (!hasActivationTerm(clause, term.asText())) all = false;
if (!all) continue;
for (JsonNode term : activation.path("any_terms")) if (hasActivationTerm(clause, term.asText())) return true;
}
return false;
}
private static boolean hasActivationTerm(String query, String term) {
if (term.matches("[a-z0-9_]+"))
return Pattern.compile("(?<![a-z0-9_])" + Pattern.quote(term) + "(?![a-z0-9_])").matcher(query).find();
return query.contains(term);
}
static void validatePublication(JsonNode document) throws IOException {
if (!"approved".equals(document.path("status").asText())) return;
JsonNode evidence = document.path("evidence");
if (!"benefit_observed".equals(evidence.path("verdict").asText()))
throw new IOException("Approved CAD knowledge recipe lacks benefit evidence");
for (String field : List.of("engine_replay", "ab_comparison", "parameter_transfer")) {
JsonNode reference = evidence.path(field);
if (reference.isTextual() && !reference.asText().isBlank()) continue;
if (!reference.isArray() || reference.isEmpty()) throw new IOException("Approved CAD knowledge recipe lacks evidence references");
for (JsonNode item : reference)
if (!item.isTextual() || item.asText().isBlank()) throw new IOException("Invalid approved CAD knowledge evidence reference");
}
}
static void validateConditions(String type, JsonNode conditions) throws IOException {
try (InputStream input = new ClassPathResource(RESOURCE_ROOT + "generation/catalog.json").getInputStream()) {
validateConditions(type, conditions, validateFactDefinitions(new ObjectMapper().readTree(input)));
}
}
private static void validateConditions(String type, JsonNode conditions, Map<String, JsonNode> definitions) throws IOException {
if (!conditions.isObject() || conditions.isEmpty()) throw new IOException("Empty CAD recipe conditions");
Set<String> present = new HashSet<>();
Iterator<Map.Entry<String, JsonNode>> entries = conditions.fields();
while (entries.hasNext()) {
Map.Entry<String, JsonNode> entry = entries.next();
JsonNode rule = entry.getValue();
JsonNode definition = definitions.get(entry.getKey());
if (definition == null || !rule.isObject() || rule.isEmpty()) throw new IOException("Invalid CAD recipe condition");
present.add(entry.getKey());
if (!"number".equals(definition.path("type").asText())) {
JsonNode expected = rule.path("equals");
if (rule.size() != 1 || "string".equals(definition.path("type").asText())
&& (!expected.isTextual() || expected.asText().isBlank() || expected.asText().length() > 80)
|| "boolean".equals(definition.path("type").asText()) && !expected.isBoolean())
throw new IOException("Invalid CAD recipe property equality");
continue;
}
Iterator<Map.Entry<String, JsonNode>> rules = rule.fields();
while (rules.hasNext()) {
Map.Entry<String, JsonNode> field = rules.next();
if (!Set.of("min", "max", "min_exclusive", "abs_min", "abs_max", "equals", "integer").contains(field.getKey())
|| "integer".equals(field.getKey()) && !field.getValue().isBoolean()
|| !"integer".equals(field.getKey()) && (!field.getValue().isNumber() || !Double.isFinite(field.getValue().asDouble())))
throw new IOException("Invalid CAD recipe numeric condition");
}
if (rule.has("min") && rule.has("min_exclusive")) throw new IOException("Duplicate CAD recipe lower bound");
double lower = rule.path("min").asDouble(rule.path("min_exclusive").asDouble(Double.NEGATIVE_INFINITY));
double upper = rule.path("max").asDouble(Double.POSITIVE_INFINITY);
if (lower > upper || rule.has("min_exclusive") && lower == upper) throw new IOException("Empty CAD recipe range");
double absoluteLower = rule.path("abs_min").asDouble(0);
double absoluteUpper = rule.path("abs_max").asDouble(Double.POSITIVE_INFINITY);
if (absoluteLower < 0 || absoluteUpper < absoluteLower
|| !rangesIntersect(lower, upper, rule.has("min_exclusive"), absoluteLower, absoluteUpper)
&& !rangesIntersect(lower, upper, rule.has("min_exclusive"), -absoluteUpper, -absoluteLower))
throw new IOException("Empty CAD recipe absolute range");
if (rule.has("equals") && !numericConditionMatches(rule, rule.path("equals").asDouble()))
throw new IOException("Conflicting CAD recipe equality");
}
if ("involute-spur-gear".equals(type) && !present.containsAll(SPUR_CONDITIONS))
throw new IOException("Missing dependent involute spur gear conditions");
}
private static boolean rangesIntersect(double lower, double upper, boolean lowerExclusive, double otherLower, double otherUpper) {
double start = Math.max(lower, otherLower);
double end = Math.min(upper, otherUpper);
return start < end || start == end && !(lowerExclusive && start == lower);
}
private static boolean numericConditionMatches(JsonNode rule, double number) {
return Double.isFinite(number)
&& (!rule.has("equals") || Math.abs(number - rule.path("equals").asDouble()) < 1e-9)
&& (!rule.has("min") || number >= rule.path("min").asDouble())
&& (!rule.has("max") || number <= rule.path("max").asDouble())
&& (!rule.has("min_exclusive") || number > rule.path("min_exclusive").asDouble())
&& (!rule.has("abs_min") || Math.abs(number) >= rule.path("abs_min").asDouble())
&& (!rule.has("abs_max") || Math.abs(number) <= rule.path("abs_max").asDouble())
&& (!rule.path("integer").asBoolean() || number == Math.rint(number));
}
static void verifyHash(byte[] bytes, String expected) throws IOException {
try {
String actual = HexFormat.of().formatHex(MessageDigest.getInstance("SHA-256").digest(bytes));
if (!actual.equals(expected)) throw new IOException("CAD knowledge recipe hash mismatch");
} catch (NoSuchAlgorithmException error) { throw new IOException("SHA-256 unavailable", error); }
}
public ObjectNode lookup(JsonNode arguments, String build) {
if ("off".equals(properties.getKnowledgeMode())) return answer("disabled", null, "专项知识已关闭;继续原助手流程,结果待验证。");
String original = arguments.path("query").asText();
if (original.toLowerCase(Locale.ROOT).matches("(?s)\\s*(?:解释|介绍|说明原理|比较|什么是|查询历史|explain|what is|compare|describe the principle).*"))
return answer("not_applicable", null, "此为说明或比较请求,无需加载建模规程;沿原助手回答。");
if (UNCERTAIN_NEGATION.matcher(currentPartQuery(original)).find())
return answer("ambiguous", null, "当前描述含双重否定或禁止范围不明确;先确认当前部件,不据此删除候选或加载规程。");
String query = positiveQuery(original);
if (query.isBlank()) return answer("ambiguous", null, "未确定当前待建部件;不加载被否定的规程。");
String selected = arguments.path("type_id").asText();
if (qualifiedGearNames(query).stream().anyMatch(QualifiedGearName::conflict))
return answer("ambiguous", selected.isBlank() ? null : selected, "当前内齿描述未明确为受支持的直齿类型,或包含冲突的内外齿限定;不加载相近规程。");
List<String> matches = coalesceMechanismComponents(candidates(query), selected);
matches = coalesceQualifiedPairName(query, matches, selected);
matches = coalesceSamePartNames(query, matches, selected);
if (!selected.isBlank() && !matches.contains(selected) && candidates(original.toLowerCase(Locale.ROOT)).contains(selected)
&& !query.equals(original.toLowerCase(Locale.ROOT)))
return answer("ambiguous", selected, "指定类型仅出现在被否定或非当前部件的文字中;不加载该规程。");
if (!selected.isBlank() && !types.containsKey(selected)) {
ObjectNode result = answer(matches.isEmpty() ? "uncovered" : "ambiguous", selected,
matches.isEmpty() ? "该类型未登记;继续原助手尝试,结果待验证。" : "指定ID未登记;query已命中候选,可省略type_id或使用返回的稳定ID重查。");
result.set("candidates", json.valueToTree(matches));
return result;
}
if (!selected.isBlank() && !matches.isEmpty() && !matches.contains(selected))
return answer("ambiguous", selected, "查询文字与指定类型不一致;请按当前部件确认类型,不能套用相近规程。");
if (selected.isBlank()) {
if (matches.size() != 1) return answer("ambiguous", null, "类型未明确;只为当前已确定的部件查询,不据传动角度猜齿制。").set("candidates", json.valueToTree(matches));
selected = matches.getFirst();
}
if (matches.size() > 1) return answer("ambiguous", selected, "包含不同类型;请仅查询当前确定的部件,不能合并加载相近规程。").set("candidates", json.valueToTree(matches));
JsonNode type = types.get(selected);
String conflictQuery = typeConflictQuery(selected, query);
for (JsonNode term : type.path("disqualifying_terms"))
if (conflictQuery.contains(term.asText().toLowerCase(Locale.ROOT)))
return answer("ambiguous", selected, "当前描述包含与该类型冲突的齿制信息;先区分类型,不加载近似规程。");
if (selected.endsWith("unspecified")) return answer("ambiguous", selected, "尚需区分齿线、节面或内外齿;不加载任何近似规程。").set("candidates", type.path("related_types"));
String finalSelected = selected;
List<Recipe> eligible = recipes.stream().filter(recipe -> finalSelected.equals(recipe.metadata().path("type_id").asText()))
.filter(recipe -> "approved".equals(recipe.metadata().path("status").asText()) || "pilot".equals(properties.getKnowledgeMode()) && "experimental".equals(recipe.metadata().path("status").asText())).toList();
if (eligible.isEmpty()) {
if ("mechanism".equals(type.path("kind").asText()))
return answer("uncovered", selected, "暂无机构规程;沿原流程设计,确定各部件类型后可分别查询,结果待验证。")
.set("related_types", type.path("related_types"));
return answer("uncovered", selected, "该类型暂无已准入规程;继续原助手尝试,结果待验证,勿套用相近齿制规程。");
}
List<Recipe> activated = eligible.stream().filter(recipe -> activationMatches(recipe.metadata().path("activation"), query)).toList();
if (activated.isEmpty()) return answer("not_applicable", selected, "当前操作无需额外提示;沿原通用技能继续,无需补参重查。");
JsonNode facts = arguments.path("facts");
List<Recipe> applicable = new ArrayList<>();
List<String> missing = new ArrayList<>();
List<String> conflicts = new ArrayList<>();
for (Recipe recipe : activated) {
List<String> absent = new ArrayList<>();
List<String> invalid = new ArrayList<>();
checkConditions(selected, recipe.metadata().path("conditions"), facts, absent, invalid);
if (absent.isEmpty() && invalid.isEmpty()) applicable.add(recipe);
missing.addAll(absent);
conflicts.addAll(invalid);
}
if (applicable.size() > 1) return answer("ambiguous", selected, "存在多个适用规程;需区分其变体条件,不自动选择相似项。");
if (applicable.isEmpty()) {
ObjectNode result = answer(conflicts.isEmpty() ? "needs_conditions" : "uncovered", selected,
conflicts.isEmpty() ? "正文未返回,尚未取得构造规程;仅当missing条件已明确采用时补齐并重查,不能据本结果声称已读取或适用。不为命中改变用户要求。" : "已给条件超出规程范围;继续原助手尝试,结果待验证,不自动改值。");
result.set("missing", json.valueToTree(missing.stream().distinct().toList()));
result.set("conflicts", json.valueToTree(conflicts.stream().distinct().toList()));
result.set("supported_conditions", activated.getFirst().metadata().path("conditions"));
return result;
}
Recipe recipe = applicable.getFirst();
String role = recipe.metadata().path("content_role").asText("recipe");
ObjectNode result = answer("matched", selected, "risk_hint".equals(role)
? "仅提示当前操作的已知风险,不是完整构造规程;新精简文本的模型收益未验证。"
: "适用当前部件;选配按用户要求,按正文表示与验证边界执行。");
result.putArray("documents").addObject().put("id", recipe.metadata().path("doc_id").asText())
.put("version", recipe.metadata().path("version").asText()).put("sha256", recipe.metadata().path("sha256").asText())
.put("status", recipe.metadata().path("status").asText()).put("content_role", role).put("text", recipe.text());
log.info("CAD knowledge matched: type={}, recipe={}, version={}", selected, recipe.metadata().path("doc_id").asText(), recipe.metadata().path("version").asText());
return result;
}
private ObjectNode answer(String status, String type, String reason) {
ObjectNode result = json.createObjectNode().put("status", status).put("reason", reason);
if (type != null) result.put("type_id", type);
result.putArray("documents");
result.putArray("missing");
return result;
}
private static boolean contains(JsonNode array, String value) {
for (JsonNode item : array) if (item.asText().equals(value)) return true;
return false;
}
static void checkConditions(String type, JsonNode conditions, JsonNode facts, List<String> missing, List<String> conflicts) {
Iterator<Map.Entry<String, JsonNode>> entries = conditions.fields();
while (entries.hasNext()) {
Map.Entry<String, JsonNode> entry = entries.next();
String name = entry.getKey();
JsonNode value = facts.get(name);
if (value == null || value.isNull()) { missing.add(name); continue; }
JsonNode rule = entry.getValue();
boolean valid;
if (rule.path("equals").isTextual() || rule.path("equals").isBoolean()) valid = rule.path("equals").equals(value);
else {
double number = value.asDouble(Double.NaN);
valid = value.isNumber() && numericConditionMatches(rule, number);
}
if (!valid) conflicts.add(name);
}
if ("involute-spur-gear".equals(type) && missing.isEmpty() && conflicts.isEmpty()) {
double module = facts.path("module_mm").asDouble();
double teeth = facts.path("teeth").asDouble();
double radius = module * teeth / 2;
double root = radius - (facts.path("addendum_coefficient").asDouble() + facts.path("clearance_coefficient").asDouble()) * module;
double base = radius * Math.cos(Math.toRadians(facts.path("pressure_angle_deg").asDouble()));
if (!Double.isFinite(root) || !Double.isFinite(base) || root <= 0 || root >= base) conflicts.add("root_radius_must_be_positive_and_below_base_radius");
}
if (!missing.isEmpty() || !conflicts.isEmpty()) return;
if ("internal-spur-gear".equals(type) && hasConditions(conditions, "module_mm", "teeth", "pressure_angle_deg", "outer_radius_mm")) {
double module = facts.path("module_mm").asDouble();
double pitch = module * facts.path("teeth").asDouble() / 2;
double root = pitch + 1.25 * module;
double tip = pitch - module;
double base = pitch * Math.cos(Math.toRadians(facts.path("pressure_angle_deg").asDouble()));
double outer = facts.path("outer_radius_mm").asDouble();
if (!Double.isFinite(root) || !Double.isFinite(tip) || !Double.isFinite(base)
|| !(outer > root && root > tip && tip > base && base > 0))
conflicts.add("internal_radii_must_satisfy_outer_gt_root_gt_tip_gt_base_gt_zero");
}
if (Set.of("helical-cylindrical-gear", "herringbone-gear", "double-helical-gear").contains(type)
&& hasConditions(conditions, "normal_module_mm", "teeth", "normal_pressure_angle_deg", "helix_angle_deg")) {
double module = facts.path("normal_module_mm").asDouble();
double cosine = Math.cos(Math.toRadians(facts.path("helix_angle_deg").asDouble()));
double pitch = module / cosine * facts.path("teeth").asDouble() / 2;
double pressure = Math.atan(Math.tan(Math.toRadians(facts.path("normal_pressure_angle_deg").asDouble())) / cosine);
double root = pitch - 1.25 * module;
double base = pitch * Math.cos(pressure);
double tip = pitch + module;
if (!Double.isFinite(root) || !Double.isFinite(base) || !Double.isFinite(tip)
|| !(root > 0 && root < base && base < tip))
conflicts.add("helical_radii_must_satisfy_zero_lt_root_lt_base_lt_tip");
}
if (Set.of("herringbone-gear", "double-helical-gear").contains(type)
&& hasConditions(conditions, "central_gap_mm", "face_width_mm")) {
double gap = facts.path("central_gap_mm").asDouble();
double width = facts.path("face_width_mm").asDouble();
if (!(gap >= 0 && gap < width)) conflicts.add("central_gap_must_leave_two_positive_width_arms");
}
if ("hex-head-bolt".equals(type)
&& hasConditions(conditions, "nominal_diameter_mm", "under_head_length_mm", "across_flats_mm", "thread_length_mm")) {
if (!(facts.path("across_flats_mm").asDouble() > facts.path("nominal_diameter_mm").asDouble()
&& facts.path("thread_length_mm").asDouble() <= facts.path("under_head_length_mm").asDouble()))
conflicts.add("hex_head_must_exceed_shank_and_thread_region_stay_below_head");
}
if ("ribbed-bearing-housing".equals(type) && hasConditions(conditions, "center_height_mm", "base_thickness_mm",
"boss_outer_diameter_mm", "bore_diameter_mm", "pedestal_width_mm", "rib_height_mm", "min_wall_mm")) {
double center = facts.path("center_height_mm").asDouble();
double base = facts.path("base_thickness_mm").asDouble();
double outer = facts.path("boss_outer_diameter_mm").asDouble();
double bore = facts.path("bore_diameter_mm").asDouble();
double wall = facts.path("min_wall_mm").asDouble();
if (!(center - outer / 2 >= base && center - bore / 2 - base >= wall
&& (outer - bore) / 2 >= wall && facts.path("pedestal_width_mm").asDouble() < outer
&& facts.path("rib_height_mm").asDouble() <= center - base))
conflicts.add("bearing_boss_pedestal_rib_and_bore_material_outside_recipe_domain");
}
if ("covered-thin-wall-enclosure".equals(type) && hasConditions(conditions, "length_mm", "width_mm", "height_mm",
"wall_thickness_mm", "bottom_thickness_mm", "lid_thickness_mm", "fastener_inset_mm",
"boss_outer_diameter_mm", "boss_height_mm", "pilot_depth_mm", "rib_height_mm", "min_wall_mm")) {
double length = facts.path("length_mm").asDouble();
double width = facts.path("width_mm").asDouble();
double height = facts.path("height_mm").asDouble();
double wall = facts.path("wall_thickness_mm").asDouble();
double bottom = facts.path("bottom_thickness_mm").asDouble();
double boss = facts.path("boss_height_mm").asDouble();
double diameter = facts.path("boss_outer_diameter_mm").asDouble();
double inset = facts.path("fastener_inset_mm").asDouble();
double minimum = facts.path("min_wall_mm").asDouble();
if (!(length > 2 * wall && width > 2 * wall && bottom < height && bottom + boss <= height
&& facts.path("pilot_depth_mm").asDouble() < boss && facts.path("rib_height_mm").asDouble() <= boss
&& inset - wall > diameter / 2 && length - 2 * inset > diameter && width - 2 * inset > diameter
&& wall >= minimum && bottom >= minimum && facts.path("lid_thickness_mm").asDouble() >= minimum))
conflicts.add("case_cavity_boss_blind_depth_fastener_or_wall_outside_recipe_domain");
}
if (Set.of("straight-bevel-gear", "spiral-bevel-gear").contains(type)
&& hasConditions(conditions, "module_mm", "teeth", "cone_angle_deg", "axial_height_mm", "geometry_representation")) {
double radius = facts.path("module_mm").asDouble() * facts.path("teeth").asDouble() / 2;
double apexHeight = radius / Math.tan(Math.toRadians(facts.path("cone_angle_deg").asDouble()));
double endScale = 1 - facts.path("axial_height_mm").asDouble() / apexHeight;
if (!Double.isFinite(radius) || !Double.isFinite(apexHeight) || !Double.isFinite(endScale)
|| !(endScale >= 0.45 && endScale <= 0.9))
conflicts.add("bevel_end_scale_must_be_between_045_and_09");
}
if ("worm".equals(type) && hasConditions(conditions, "axial_module_mm", "pitch_diameter_mm", "worm_starts", "axial_length_mm")) {
double module = facts.path("axial_module_mm").asDouble();
double root = facts.path("pitch_diameter_mm").asDouble() / 2 - 1.25 * module;
double pitch = Math.PI * module;
double lead = facts.path("worm_starts").asDouble() * pitch;
double length = facts.path("axial_length_mm").asDouble();
double turns = (length + 2 * lead) / lead;
if (!Double.isFinite(root) || !Double.isFinite(pitch) || !Double.isFinite(lead) || !Double.isFinite(turns)
|| !(root > 0.1 * module && length >= pitch && turns <= 200))
conflicts.add("worm_core_length_and_turns_outside_recipe_domain");
}
if ("worm-wheel".equals(type) && hasConditions(conditions, "module_mm", "teeth", "pressure_angle_deg", "pitch_diameter_mm", "face_width_mm", "geometry_representation")) {
double module = facts.path("module_mm").asDouble();
double pitch = module * facts.path("teeth").asDouble() / 2;
double wormRadius = facts.path("pitch_diameter_mm").asDouble() / 2;
double halfWidth = facts.path("face_width_mm").asDouble() / 2;
double major = pitch + wormRadius;
double minor = wormRadius - module;
double base = pitch * Math.cos(Math.toRadians(facts.path("pressure_angle_deg").asDouble()));
double midRadius = major - minor;
double radicand = minor * minor - halfWidth * halfWidth;
double endRadius = major - Math.sqrt(radicand);
double blankTip = pitch + 1.5 * module;
if (!Double.isFinite(base) || !Double.isFinite(midRadius) || !Double.isFinite(radicand)
|| !Double.isFinite(endRadius) || !Double.isFinite(blankTip)
|| !(minor > halfWidth && halfWidth > 0 && base < midRadius && midRadius < endRadius
&& endRadius < blankTip - 0.005 * module))
conflicts.add("worm_wheel_throat_outside_recipe_domain");
}
}
private static boolean hasConditions(JsonNode conditions, String... names) {
for (String name : names) if (!conditions.has(name)) return false;
return true;
}
private static String currentPartQuery(String query) {
return query.toLowerCase(Locale.ROOT).replaceFirst("(?s)^.*(当前只造|当前只做|当前待修改部件是|中先做|只造)", "$1");
}
private static String typeConflictQuery(String type, String query) {
// A clause declaring absent optional features does not assert those features.
// Do not cross a positive replacement, independent target, or clause boundary.
String focused = query;
if (Set.of("mounting-plate", "covered-thin-wall-enclosure").contains(type))
focused = query.replaceAll("(^|[,,。;;\\s])(?:无|没有|不加|不设(?:置)?|不含|不包含|不带|不留)[^,,。;;\\n\\d]*?(?=,|,|。|;|;|\\n|但|而|仍|却|保留|改用|改成|换成|另(?:做|加|有|带|留)|或(?:有|带|保留|生成)|$)", "$1");
if (!"herringbone-gear".equals(type)) return focused;
// Absence and a literal zero-width attribute are not a grooved tooth structure.
// Scope to complete attribute clauses; keep positive/uncertain conflicts and facts.
return focused.replaceAll("(^|[,,。;;\\s])(?:无|没有|不带|不设(?:置)?|不含|不留)\\s*(?:中央|中心)?\\s*(?:退刀槽|槽)(?=\\s*(?:[,,。;;\\n]|$))", "$1")
.replaceAll("(^|[,,。;;\\s])(?:中央|中心)?(?:退刀)?槽(?:的)?(?:轴向)?宽(?:度)?\\s*(?:为|等于|=|:|:)?\\s*0(?:\\.0+)?(?![\\d.])\\s*(?:mm|毫米)?(?=\\s*(?:[,,。;;\\n]|$))", "$1")
.replaceAll("\\bno\\s+(?:a\\s+)?(?:central\\s+)?(?:groove|gap)\\b(?=\\s*(?:[,.;]|$))", " ")
.replaceAll("\\b(?:central\\s+)?(?:gap|groove)(?:\\s+width)?\\s*(?:=|:|is|of)?\\s*0(?:\\.0+)?(?![\\d.])\\s*(?:mm)?(?=\\s*(?:[,.;]|$))", " ");
}
private String positiveQuery(String query) {
// A prohibited substitution stays negative through its entire clause. A verb such
// as “用” or “改成” inside that clause does not introduce a positive alternative.
String focused = currentPartQuery(query).replaceAll("(?:不得|禁止|严禁|不可|不能|切勿|请勿|勿|不允许|不准|不许|不应|避免|不要(?:将|把|使用|采用|用|以|拿)|\\b(?:do|must|should)\\s+not\\b|\\bnever\\b)[^,,。;;\\n]*", " ");
// Simple rejected alternatives can still precede an explicit replacement marker.
focused = focused.replaceAll("(?:不要|不是|不用|不做|不造|不需要|不生成|不创建|不制作|不建|改掉|\\bwithout\\b|\\bnot\\b)[^,,。;;\\n]*?(?=,|,|。|;|;|\\n|改用|换成|改成|而是|但(?:要)?(?:生成|制作|创建|构造)|$)", " ");
Matcher references = referenceNames.matcher(focused);
StringBuilder positive = new StringBuilder();
while (references.find()) {
// A reference object is not a creation target, unless the request explicitly
// creates that reference object. Keep dimensions as prose, never infer facts.
boolean created = REFERENCE_CREATION.matcher(focused.substring(0, references.start())).matches();
references.appendReplacement(positive, created ? Matcher.quoteReplacement(references.group()) : " ");
}
references.appendTail(positive);
focused = positive.toString();
Matcher companions = companionNames.matcher(focused);
positive = new StringBuilder();
while (companions.find()) {
String prefix = focused.substring(0, companions.start());
List<String> targets = candidates(prefix);
List<String> referencesOnly = candidates(companions.group());
// A companion with an interface dimension is a reference only after one
// explicit, different target. Joined or independently created parts remain.
boolean reference = targets.size() == 1 && !referencesOnly.contains(targets.getFirst())
&& TARGET_INTENT.matcher(prefix).find() && !JOINED_TARGET.matcher(prefix).matches()
&& !REFERENCE_CREATION.matcher(prefix).matches()
&& !TARGET_INTENT.matcher(focused.substring(companions.end()).split("[,,。;;\\r\\n]", 2)[0]).find();
companions.appendReplacement(positive, reference ? " " : Matcher.quoteReplacement(companions.group()));
}
companions.appendTail(positive);
focused = positive.toString();
Matcher interfaces = SHAFT_INTERFACE.matcher(focused);
positive = new StringBuilder();
while (interfaces.find()) {
String prefix = focused.substring(0, interfaces.start());
boolean reference = candidates(prefix).equals(List.of("stepped-shaft"))
&& TARGET_INTENT.matcher(prefix).find() && !JOINED_TARGET.matcher(prefix).matches()
&& !REFERENCE_CREATION.matcher(prefix).matches();
interfaces.appendReplacement(positive, reference ? "配合孔" : Matcher.quoteReplacement(interfaces.group()));
}
interfaces.appendTail(positive);
return positive.toString();
}
private static Pattern referenceNames(Map<String, JsonNode> types) {
String object = objectNames(types);
return Pattern.compile("(?:参考" + REFERENCE_MODIFIERS + object
+ "|\\breference\\s+(?:(?:existing|known)\\s+)?" + object
+ "|" + object + "\\s*(?:仅作为|只作为|作为|仅供|只供)\\s*参考)");
}
private static String objectNames(Map<String, JsonNode> types) {
Set<String> names = new HashSet<>();
for (JsonNode type : types.values()) for (JsonNode alias : type.path("aliases")) names.add(alias.asText().toLowerCase(Locale.ROOT));
String alternatives = names.stream().sorted(Comparator.comparingInt(String::length).reversed().thenComparing(Comparator.naturalOrder()))
.map(Pattern::quote).reduce((left, right) -> left + "|" + right).orElse("(?!)");
return "(?:" + alternatives + ")";
}
private List<String> coalesceMechanismComponents(List<String> matches, String selected) {
JsonNode mechanism = types.get(selected);
if (mechanism == null || !"mechanism".equals(mechanism.path("kind").asText()) || !matches.contains(selected)) return matches;
// An explicitly selected mechanism and its registered components describe one assembly.
// Never absorb an unrelated type, another mechanism, or an unregistered relationship.
Set<String> components = new HashSet<>();
for (JsonNode component : mechanism.path("related_types")) components.add(component.asText());
for (String id : matches) {
if (id.equals(selected) || components.contains(id)) continue;
JsonNode candidate = types.get(id);
boolean correspondingGeneralType = id.endsWith("unspecified") && candidate != null;
if (correspondingGeneralType) {
correspondingGeneralType = false;
for (JsonNode subtype : candidate.path("related_types"))
if (components.contains(subtype.asText())) correspondingGeneralType = true;
}
if (!correspondingGeneralType) return matches;
}
return List.of(selected);
}
private List<String> coalesceSamePartNames(String query, List<String> matches, String selected) {
// A shape description may repeat the general noun for the same specified part.
// Preserve separate components and every independently specified alternate subtype.
if (query.matches("(?s).*(?:另一个|另一件|另外|另做|另加|再做|再加|第二个|第二件|多个|各一个|分别|another|additional|second|separate|different|two gears|[两二2](?:个|只|件|种)).*")
|| query.matches("(?s).*(?:和|及|与|以及|and)\\s*(?:一个|一件|一只|one\\b|a\\b|an\\b|another|另|齿轮|gear\\b).*")) return matches;
List<String> specific = matches.stream().filter(id -> !id.endsWith("unspecified")).toList();
if (specific.size() != 1 || !selected.isBlank() && !selected.equals(specific.getFirst())) return matches;
String subtype = specific.getFirst();
return matches.stream().filter(id -> !id.endsWith("unspecified")
|| !contains(types.get(id).path("related_types"), subtype)).toList();
}
private List<String> coalesceQualifiedPairName(String query, List<String> matches, String selected) {
JsonNode part = types.get(selected);
JsonNode pair = types.get("gear-pair");
if (part == null || !"part".equals(part.path("kind").asText()) || pair == null
|| !matches.contains(selected) || !matches.contains("gear-pair")) return matches;
// A selected part may qualify the same noun as “double-helical gear pair”.
// Absorb only overlapping names; an independent pair remains another target.
for (JsonNode alias : pair.path("aliases")) {
String term = alias.asText().toLowerCase(Locale.ROOT);
int from = 0;
int at;
while ((at = query.indexOf(term, from)) >= 0) {
from = at + term.length();
String shared = "齿轮副".equals(term) ? "齿轮" : "gear pair".equals(term) ? "gear" : null;
if (shared == null) return matches;
boolean qualified = false;
for (JsonNode partAlias : part.path("aliases")) {
String name = partAlias.asText().toLowerCase(Locale.ROOT);
int start = at + shared.length() - name.length();
if (name.endsWith(shared) && start >= 0 && query.startsWith(name, start)
&& (!"gear".equals(shared) || start == 0 || !isLatinLetter(query.charAt(start - 1)))) {
qualified = true;
break;
}
}
if (!qualified) return matches;
}
}
return matches.stream().filter(id -> !"gear-pair".equals(id)).toList();
}
private static boolean isLatinLetter(char character) { return character >= 'a' && character <= 'z'; }
private static List<QualifiedGearName> qualifiedGearNames(String query) {
// Compose local name modifiers instead of adding complete user sentences as aliases.
// The span cannot cross punctuation or conjunctions into a different component.
List<QualifiedGearName> names = new ArrayList<>();
for (Pattern pattern : QUALIFIED_GEAR_NAMES) {
Matcher matcher = pattern.matcher(query);
while (matcher.find()) {
String name = matcher.group();
boolean internal = name.contains("内") || name.contains("internal");
boolean external = name.contains("外") || name.contains("external");
boolean qualified = name.matches("(?s).*(?:渐开线|直齿|斜齿|螺旋|圆柱|环形|锥齿|圆锥|involute|spur|helical|bevel|cylindrical|ring).*");
if ((!internal && !external) || !qualified) continue;
boolean straight = name.contains("直齿") || name.contains("spur");
boolean otherToothForm = name.matches("(?s).*(?:斜齿|螺旋|锥齿|圆锥|helical|bevel).*");
boolean conflict = internal && (external || !straight || otherToothForm);
String type = straight && !otherToothForm && !conflict
? internal ? "internal-spur-gear" : "involute-spur-gear" : null;
if (type != null || conflict)
names.add(new QualifiedGearName(matcher.group(), type, matcher.start(), matcher.end(), conflict));
}
}
return names;
}
private List<String> candidates(String query) {
record Hit(String id, String alias, int start, int end) {}
List<Hit> hits = new ArrayList<>();
for (Map.Entry<String, JsonNode> entry : types.entrySet()) for (JsonNode alias : entry.getValue().path("aliases")) {
String term = alias.asText().toLowerCase(Locale.ROOT);
int from = 0;
int at;
while ((at = query.indexOf(term, from)) >= 0) {
from = at + term.length();
if ("齿轮".equals(term) && query.startsWith("齿轮箱", at)) continue;
if (term.matches("[a-z -]+") && (at > 0 && isLatinLetter(query.charAt(at - 1))
|| at + term.length() < query.length() && isLatinLetter(query.charAt(at + term.length())))) continue;
hits.add(new Hit(entry.getKey(), term, at, from));
}
}
for (QualifiedGearName name : qualifiedGearNames(query))
if (name.type() != null) hits.add(new Hit(name.type(), name.name(), name.start(), name.end()));
// A general “gear” inside a precise alias is not an independent candidate.
return hits.stream().filter(hit -> hits.stream().noneMatch(other -> !other.id().equals(hit.id()) && other.start() <= hit.start() && other.end() >= hit.end() && other.alias().length() > hit.alias().length()))
.map(Hit::id).distinct().sorted().toList();
}
/** Runs during process-classes even when Maven is invoked with -DskipTests. */
public static void main(String[] arguments) throws IOException {
new CadAiKnowledge(new ObjectMapper(), new CadAiProperties());
}
}