@tasksai/install 0.1.30 → 0.1.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tasksai/install",
-  "version": "0.1.30",
+  "version": "0.1.31",
   "description": "Shared TasksAI MCP installer CLI",
   "type": "module",
   "bin": {

package/runtime/skill_matcher.py

@@ -11,7 +11,7 @@ import unicodedata
 from collections.abc import Iterable, Mapping, Sequence
 
 
-POLICY_VERSION = "tasksai-trigger-matcher/2.0"
+POLICY_VERSION = "tasksai-trigger-matcher/2.1"
 
 DEFAULT_STOP_WORDS = {
     "a", "an", "and", "are", "as", "at", "be", "by", "can", "create",
@@ -57,11 +57,44 @@ DEFAULT_CONTEXT_WORDS = {
 DEFAULT_THRESHOLDS = {"high": 90, "medium": 45}
 DEFAULT_RESULT_COUNT = 3
 MAXIMUM_RESULT_COUNT = 10
+DEFAULT_RESULT_COUNTS = {"realtor": 5}
+REALTOR_ACTION_WORDS = {
+    "assemble", "build", "create", "develop", "document", "draft",
+    "generate", "make", "prepare", "produce", "write", "writing",
+}
+DEFAULT_TOKEN_ALIASES = {
+    "realtor": {
+        "assemble": "create",
+        "build": "create",
+        "develop": "create",
+        "draft": "create",
+        "dwelling": "property",
+        "generate": "create",
+        "home": "property",
+        "house": "property",
+        "listed": "listing",
+        "listings": "listing",
+        "list": "listing",
+        "make": "create",
+        "prepare": "create",
+        "prepared": "create",
+        "preparing": "create",
+        "preparation": "create",
+        "produce": "create",
+        "residence": "property",
+        "residential": "property",
+        "write": "create",
+        "writing": "create",
+    },
+}
 TRIGGER_EVIDENCE_RANK = {
-    "trigger_exact": 4,
+    "trigger_exact": 5,
+    "trigger_equivalent": 4,
     "trigger_complete": 3,
     "trigger_query_complete": 2,
-    "trigger_partial": 1,
+    "trigger_partial": 2,
+    "trigger_broad": 1,
+    "trigger_context": 1,
 }
 
 
@@ -149,9 +182,95 @@ def _normalize_scoring_tokens(
     value: object,
     stop_words: set[str],
     abbreviations: Mapping[str, object],
+    token_aliases: Mapping[str, str],
 ) -> tuple[str, ...]:
     expanded = _expand_abbreviations(_tokens(value), abbreviations)
-    return tuple(token for token in expanded if token not in stop_words)
+    canonical = tuple(token_aliases.get(token, token) for token in expanded)
+    return tuple(token for token in canonical if token not in stop_words)
+
+
+def _same_token_bag(left: tuple[str, ...], right: tuple[str, ...]) -> bool:
+    return bool(left) and len(left) == len(right) and sorted(left) == sorted(right)
+
+
+def _within_one_edit(left: str, right: str) -> bool:
+    """Return True for one insertion, deletion, substitution, or transposition."""
+    if left == right or abs(len(left) - len(right)) > 1:
+        return False
+    if len(left) == len(right):
+        differences = [index for index, pair in enumerate(zip(left, right)) if pair[0] != pair[1]]
+        if len(differences) == 1:
+            return True
+        return (
+            len(differences) == 2
+            and differences[1] == differences[0] + 1
+            and left[differences[0]] == right[differences[1]]
+            and left[differences[1]] == right[differences[0]]
+        )
+    shorter, longer = (left, right) if len(left) < len(right) else (right, left)
+    short_index = long_index = differences = 0
+    while short_index < len(shorter) and long_index < len(longer):
+        if shorter[short_index] == longer[long_index]:
+            short_index += 1
+            long_index += 1
+            continue
+        differences += 1
+        long_index += 1
+        if differences > 1:
+            return False
+    return True
+
+
+def _build_token_index(
+    skills: Sequence[Mapping[str, object]],
+    triggers: Mapping[str, object],
+    product_id: str,
+    policy: Mapping[str, object],
+) -> tuple[dict[tuple[int, str], set[str]], set[str]]:
+    """Index public discovery tokens by length and first character for bounded typo repair."""
+    stop_words = policy["stop_words"]
+    abbreviations = policy["abbreviations"]
+    token_aliases = policy["token_aliases"]
+    vocabulary = set(token_aliases) | set(token_aliases.values())
+    for skill in skills:
+        for value in (skill.get("name", ""), _category_text(skill)):
+            vocabulary.update(
+                _normalize_scoring_tokens(value, stop_words, abbreviations, token_aliases)
+            )
+        skill_id = str(skill.get("id", ""))
+        for trigger in _trigger_values(triggers, skill_id, product_id):
+            vocabulary.update(
+                _normalize_scoring_tokens(trigger, stop_words, abbreviations, token_aliases)
+            )
+    index: dict[tuple[int, str], set[str]] = {}
+    for token in vocabulary:
+        if len(token) < 5:
+            continue
+        index.setdefault((len(token), token[0]), set()).add(token)
+    return index, vocabulary
+
+
+def _repair_query_tokens(
+    tokens: tuple[str, ...],
+    token_index: Mapping[tuple[int, str], set[str]],
+    vocabulary: set[str],
+) -> tuple[tuple[str, ...], list[str]]:
+    repaired: list[str] = []
+    diagnostics: list[str] = []
+    for token in tokens:
+        if len(token) < 5 or token in vocabulary:
+            repaired.append(token)
+            continue
+        candidates: set[str] = set()
+        for length in range(len(token) - 1, len(token) + 2):
+            candidates.update(token_index.get((length, token[0]), set()))
+        matches = sorted(candidate for candidate in candidates if _within_one_edit(token, candidate))
+        if len(matches) == 1:
+            repaired.append(matches[0])
+            diagnostics.append(f"fuzzy_corrected:{token}->{matches[0]}")
+        else:
+            repaired.append(token)
+    return tuple(repaired), diagnostics
 
 
 def _contains_tokens(container: tuple[str, ...], candidate: tuple[str, ...]) -> bool:
@@ -222,6 +341,8 @@ def _resolve_config(product_id: str, config: Mapping[str, object] | None) -> tup
         for value in supplied_stop_words
         for token in _tokens(value)
     }
+    if _canonical_product_id(product_id) == "realtor":
+        stop_words.difference_update(REALTOR_ACTION_WORDS)
     context_default = DEFAULT_CONTEXT_WORDS.get(_canonical_product_id(product_id), set())
     supplied_context_words = source.get("context_words", context_default)
     if not isinstance(supplied_context_words, Sequence) or isinstance(supplied_context_words, (str, bytes)):
@@ -242,10 +363,13 @@ def _resolve_config(product_id: str, config: Mapping[str, object] | None) -> tup
         diagnostics.append("bundled_thresholds:invalid_order")
         thresholds = dict(DEFAULT_THRESHOLDS)
 
-    default_count = source.get("default_result_count", DEFAULT_RESULT_COUNT)
+    product_default_count = DEFAULT_RESULT_COUNTS.get(
+        _canonical_product_id(product_id), DEFAULT_RESULT_COUNT
+    )
+    default_count = source.get("default_result_count", product_default_count)
     maximum_count = source.get("maximum_result_count", MAXIMUM_RESULT_COUNT)
     if not isinstance(default_count, int) or isinstance(default_count, bool) or default_count < 1:
-        default_count = DEFAULT_RESULT_COUNT
+        default_count = product_default_count
     if not isinstance(maximum_count, int) or isinstance(maximum_count, bool) or maximum_count < 1:
         maximum_count = MAXIMUM_RESULT_COUNT
     maximum_count = min(maximum_count, MAXIMUM_RESULT_COUNT)
@@ -262,6 +386,8 @@ def _resolve_config(product_id: str, config: Mapping[str, object] | None) -> tup
         "default_result_count": default_count,
         "maximum_result_count": maximum_count,
         "abbreviations": configured_abbreviations,
+        "token_aliases": DEFAULT_TOKEN_ALIASES.get(_canonical_product_id(product_id), {}),
+        "broad_matching": _canonical_product_id(product_id) == "realtor",
     }, diagnostics
 
 
@@ -271,8 +397,12 @@ def _score_trigger(
     stop_words: set[str],
     context_words: set[str],
     abbreviations: Mapping[str, object],
+    token_aliases: Mapping[str, str],
+    broad_matching: bool,
 ) -> tuple[int, int, set[str], str]:
-    trigger_tokens = _normalize_scoring_tokens(trigger, stop_words, abbreviations)
+    trigger_tokens = _normalize_scoring_tokens(
+        trigger, stop_words, abbreviations, token_aliases
+    )
     if not trigger_tokens:
         return 0, 0, set(), ""
 
@@ -284,10 +414,14 @@ def _score_trigger(
 
     if query_tokens == trigger_tokens:
         return 120, specificity, matched, "trigger_exact"
+    if broad_matching and _same_token_bag(query_tokens, trigger_tokens):
+        return 110, specificity, matched, "trigger_equivalent"
     if _contains_tokens(query_tokens, trigger_tokens):
         bonus = min(15, max(0, specificity - 1) * 3)
         return 90 + bonus, specificity, matched, "trigger_complete"
     query_specific = query_set - context_words
+    if broad_matching and not query_specific and query_set and query_set <= trigger_set:
+        return 50, specificity, matched, "trigger_context"
     if len(query_specific) >= 2 and _contains_tokens(trigger_tokens, query_tokens):
         return 70, specificity, matched, "trigger_query_complete"
 
@@ -296,6 +430,10 @@ def _score_trigger(
     coverage = len(covered) / len(coverage_tokens)
     if len(covered) >= 2 and coverage >= 0.67:
         return round(40 * coverage), specificity, matched, "trigger_partial"
+    matched_specific_query = matched & (query_set - context_words)
+    matched_context = matched & context_words
+    if broad_matching and matched_specific_query and matched_context:
+        return 35, specificity, matched, "trigger_broad"
     return 0, specificity, set(), ""
 
 
@@ -309,6 +447,8 @@ def _score_skill(
     stop_words = policy["stop_words"]
     context_words = policy["context_words"]
     abbreviations = policy["abbreviations"]
+    token_aliases = policy["token_aliases"]
+    broad_matching = policy["broad_matching"]
     query_set = set(query_tokens)
     specific_query = query_set - context_words
     context_query = query_set & context_words
@@ -317,7 +457,8 @@ def _score_skill(
     strongest_trigger = (0, 0, set(), "", "")
     for trigger in _trigger_values(triggers, skill_id, product_id):
         score, specificity, matched, evidence = _score_trigger(
-            query_tokens, trigger, stop_words, context_words, abbreviations
+            query_tokens, trigger, stop_words, context_words, abbreviations,
+            token_aliases, broad_matching
         )
         candidate = (score, specificity, matched, evidence, normalize_text(trigger))
         candidate_key = (score, specificity, len(matched), normalize_text(trigger))
@@ -335,7 +476,7 @@ def _score_skill(
     matched_tokens = set(trigger_matched)
 
     name_tokens = _normalize_scoring_tokens(
-        skill.get("name", ""), stop_words, abbreviations
+        skill.get("name", ""), stop_words, abbreviations, token_aliases
     )
     name_set = set(name_tokens)
     identity_score = 0
@@ -352,7 +493,9 @@ def _score_skill(
         evidence.append(f"name_context:{token}")
 
     category_set = set(
-        _normalize_scoring_tokens(_category_text(skill), stop_words, abbreviations)
+        _normalize_scoring_tokens(
+            _category_text(skill), stop_words, abbreviations, token_aliases
+        )
     )
     category_score = 0
     for token in sorted(specific_query & category_set):
@@ -365,7 +508,9 @@ def _score_skill(
         evidence.append(f"category_context:{token}")
 
     description_set = set(
-        _normalize_scoring_tokens(skill.get("description", ""), stop_words, abbreviations)
+        _normalize_scoring_tokens(
+            skill.get("description", ""), stop_words, abbreviations, token_aliases
+        )
     )
     description_matches = sorted(specific_query & description_set)
     description_score = len(description_matches)
@@ -457,7 +602,28 @@ def match_skills(
 
     raw_tokens = _tokens(query)
     expanded_tokens = _expand_abbreviations(raw_tokens, configured_abbreviations)
-    query_tokens = tuple(token for token in expanded_tokens if token not in policy["stop_words"])
+    aliased_tokens = tuple(
+        policy["token_aliases"].get(token, token) for token in expanded_tokens
+    )
+    initial_query_tokens = tuple(
+        token for token in aliased_tokens if token not in policy["stop_words"]
+    )
+
+    scoped_skills = [skill for skill in skills if _belongs_to_product(skill, product_id)]
+    if policy["broad_matching"]:
+        token_index, vocabulary = _build_token_index(
+            scoped_skills, triggers, product_id, policy
+        )
+        repaired_tokens, fuzzy_diagnostics = _repair_query_tokens(
+            initial_query_tokens, token_index, vocabulary
+        )
+    else:
+        repaired_tokens, fuzzy_diagnostics = initial_query_tokens, []
+    query_tokens = tuple(
+        policy["token_aliases"].get(token, token) for token in repaired_tokens
+        if policy["token_aliases"].get(token, token) not in policy["stop_words"]
+    )
+    diagnostics.extend(fuzzy_diagnostics)
     query_normalized = " ".join(query_tokens)
 
     requested_count = policy["default_result_count"] if result_count is None else result_count
@@ -465,7 +631,6 @@ def match_skills(
         requested_count = policy["default_result_count"]
     requested_count = max(1, min(requested_count, policy["maximum_result_count"]))
 
-    scoped_skills = [skill for skill in skills if _belongs_to_product(skill, product_id)]
     if len(scoped_skills) != len(skills):
         diagnostics.append("product_mismatches_filtered")