@vibekiln/cutline-mcp-cli 0.8.0 → 0.8.1

package/dist/servers/cutline-server.js

@@ -2291,6 +2291,19 @@ function healBindings(entities, bindings, filePaths) {
     total_entities: entities.length
   };
 }
+function findBoundEntities(filePath, bindings) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const matched = /* @__PURE__ */ new Set();
+  for (const binding of bindings) {
+    for (const pattern of binding.file_patterns) {
+      if (globMatch(normalized, pattern)) {
+        matched.add(binding.entity_id);
+        break;
+      }
+    }
+  }
+  return [...matched];
+}
 function tokenize(name2) {
   return name2.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length > 2);
 }
@@ -7489,6 +7502,59 @@ function inferEntityNameFromTask(task) {
 function normalizeName(value) {
   return value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
 }
+function canonicalizeBindings(bindings, entities) {
+  const entityTypes = new Map(entities.map((e) => [e.id, e.type]));
+  const normalized = [];
+  for (const raw of bindings) {
+    const legacyRaw = raw;
+    const entityId = typeof raw.entity_id === "string" ? raw.entity_id : typeof legacyRaw.entityId === "string" ? legacyRaw.entityId : void 0;
+    if (!entityId || !entityTypes.has(entityId))
+      continue;
+    if (!Array.isArray(raw.file_patterns) || raw.file_patterns.length === 0)
+      continue;
+    const filePatterns = raw.file_patterns.filter((v) => typeof v === "string");
+    if (filePatterns.length === 0)
+      continue;
+    normalized.push({
+      id: typeof raw.id === "string" ? raw.id : `bind:${entityId}`,
+      entity_id: entityId,
+      entity_type: typeof raw.entity_type === "string" ? raw.entity_type : entityTypes.get(entityId),
+      file_patterns: filePatterns,
+      confidence: typeof raw.confidence === "number" ? raw.confidence : 0.5,
+      manual: Boolean(raw.manual)
+    });
+  }
+  return normalized;
+}
+function rankEntitiesForFilePath(filePath, entities) {
+  const normalizedPath = filePath.toLowerCase().replace(/\\/g, "/");
+  const fileStem = normalizedPath.split("/").pop()?.replace(/\.[^.]+$/, "") ?? "";
+  const pathTokens = new Set(normalizedPath.replace(/\.[^.]+$/, "").split(/[\/._-]/).filter((t) => t.length >= 3));
+  const scored = entities.map((entity) => {
+    const labels = [entity.name, ...entity.aliases].filter(Boolean);
+    if (labels.length === 0)
+      return { entity, score: 0 };
+    let score = 0;
+    for (const label of labels) {
+      const labelNorm = normalizeName(label);
+      const labelTokens = labelNorm.split("_").filter((t) => t.length >= 3);
+      if (labelTokens.length === 0)
+        continue;
+      const matchedTokens = labelTokens.filter((t) => pathTokens.has(t)).length;
+      if (matchedTokens > 0) {
+        score = Math.max(score, matchedTokens / labelTokens.length);
+      }
+      if (normalizedPath.includes(labelNorm.replace(/_/g, "/"))) {
+        score = Math.max(score, 0.9);
+      }
+      if (fileStem === labelNorm || fileStem.includes(labelNorm) || labelNorm.includes(fileStem)) {
+        score = Math.max(score, 0.8);
+      }
+    }
+    return { entity, score };
+  }).filter((item) => item.score >= 0.45).sort((a, b) => b.score - a.score);
+  return scored.map((item) => item.entity);
+}
 async function seedScopeEntityFromAuto(params) {
   const { product_id, name: name2, entity_type, description, parent_id, tags, similarity_threshold } = params;
   const slug = normalizeName(name2).slice(0, 40);
@@ -9557,7 +9623,6 @@ ${recommendation}`;
                   used_category_prefilter: usePreFilter,
                   phase: autoPhase,
                   rgr_plan: autoRgrPlan || void 0,
-                  requested_outcome: requestedOutcome,
                   scope_expansion: scopeExpansion,
                   scope_seeded: scopeSeedResult || void 0,
                   requested_outcome: requestedOutcome
@@ -10414,20 +10479,22 @@ ${JSON.stringify(metrics, null, 2)}` }
               }]
             };
           }
-          const rgrTraverser = new GraphTraverser(rgrEntities, rgrEdges, rgrConstraints, rgrBindings);
+          const normalizedBindings = canonicalizeBindings(rgrBindings, rgrEntities);
+          const rgrTraverser = new GraphTraverser(rgrEntities, rgrEdges, rgrConstraints, normalizedBindings);
           const rgrMatched = rgrTraverser.findEntitiesByFilePath(file_path);
           if (rgrMatched.length === 0) {
-            const segs = file_path.split("/").pop()?.replace(/\.[^.]+$/, "")?.split(/[-_]/) ?? [];
-            for (const seg of segs) {
-              if (seg.length > 2) {
-                const found = rgrTraverser.findEntityByName(seg);
-                if (found) {
-                  rgrMatched.push(found);
-                  break;
-                }
+            const reverseMatchedIds = findBoundEntities(file_path, normalizedBindings);
+            for (const id of reverseMatchedIds) {
+              const found = rgrEntities.find((entity) => entity.id === id);
+              if (found) {
+                rgrMatched.push(found);
               }
             }
           }
+          if (rgrMatched.length === 0) {
+            const rankedFallback = rankEntitiesForFilePath(file_path, rgrEntities).slice(0, 2);
+            rgrMatched.push(...rankedFallback);
+          }
           if (rgrMatched.length === 0) {
             const governance2 = buildGovernanceEnvelope({
               decision: "revise",

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vibekiln/cutline-mcp-cli",
-    "version": "0.8.0",
+    "version": "0.8.1",
     "description": "CLI and MCP servers for Cutline — authenticate, then run constraint-aware MCP servers in Cursor or any MCP client.",
     "type": "module",
     "main": "dist/index.js",