@vibekiln/cutline-mcp-cli 0.7.0 → 0.8.1

package/Dockerfile

@@ -3,7 +3,11 @@ FROM node:20-slim AS base
 WORKDIR /app
 
 # Install the CLI globally from npm (includes bundled servers)
-RUN npm install -g @vibekiln/cutline-mcp-cli@latest
+# Override at build time for staging package:
+#   --build-arg PACKAGE_NAME=@kylewadegrove/cutline-mcp-cli-staging
+ARG PACKAGE_NAME=@vibekiln/cutline-mcp-cli
+ARG PACKAGE_TAG=latest
+RUN npm install -g "${PACKAGE_NAME}@${PACKAGE_TAG}"
 
 # Default to the main constraints server (cutline-server.js)
 # Override with: docker run ... cutline-mcp serve premortem

package/dist/commands/init.js

@@ -1,11 +1,35 @@
 import chalk from 'chalk';
 import ora from 'ora';
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { createInterface } from 'node:readline';
 import { resolve, join } from 'node:path';
 import { getRefreshToken } from '../auth/keychain.js';
 import { fetchFirebaseApiKey } from '../utils/config.js';
 import { saveConfig, loadConfig } from '../utils/config-store.js';
 const CUTLINE_CONFIG = '.cutline/config.json';
+function prompt(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolvePrompt) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolvePrompt(answer.trim());
+        });
+    });
+}
+async function fetchProducts(idToken, baseUrl) {
+    try {
+        const res = await fetch(`${baseUrl}/mcpListProducts`, {
+            headers: { Authorization: `Bearer ${idToken}` },
+        });
+        if (!res.ok)
+            return { products: [], requestOk: false };
+        const data = await res.json();
+        return { products: data.products ?? [], requestOk: true };
+    }
+    catch {
+        return { products: [], requestOk: false };
+    }
+}
 async function authenticate(options) {
     const refreshToken = await getRefreshToken();
     if (!refreshToken)
@@ -53,6 +77,13 @@ function readCutlineConfig(projectRoot) {
         return null;
     }
 }
+function writeCutlineConfig(projectRoot, config) {
+    const cutlineDir = join(projectRoot, '.cutline');
+    const configPath = join(cutlineDir, 'config.json');
+    mkdirSync(cutlineDir, { recursive: true });
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+    return configPath;
+}
 function cursorRgrRule(config, tier) {
     const productId = config?.product_id ?? '<from .cutline/config.json>';
     const productName = config?.product_name ?? 'your product';
@@ -203,7 +234,8 @@ function ensureGitignore(projectRoot, patterns) {
 }
 export async function initCommand(options) {
     const projectRoot = resolve(options.projectRoot ?? process.cwd());
-    const config = readCutlineConfig(projectRoot);
+    let config = readCutlineConfig(projectRoot);
+    const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
     const scanUrl = options.staging
         ? 'https://cutline-staging.web.app/scan'
         : 'https://thecutline.ai/scan';
@@ -222,6 +254,79 @@ export async function initCommand(options) {
         tier = auth.tier;
         spinner.succeed(chalk.green(`Authenticated as ${auth.email} (${tier})`));
     }
+    if (tier === 'premium' && auth?.idToken && auth.baseUrl) {
+        const productsSpinner = ora('Fetching product graphs for normalization...').start();
+        const { products, requestOk } = await fetchProducts(auth.idToken, auth.baseUrl);
+        productsSpinner.stop();
+        if (requestOk && products.length > 0) {
+            const currentIndex = config?.product_id
+                ? products.findIndex((p) => p.id === config?.product_id)
+                : -1;
+            let selected;
+            if (isInteractive) {
+                console.log(chalk.bold('\n  Select canonical product for rule generation\n'));
+                products.forEach((p, i) => {
+                    const date = p.createdAt
+                        ? chalk.dim(` (${new Date(p.createdAt).toLocaleDateString()})`)
+                        : '';
+                    const currentTag = currentIndex === i ? chalk.green(' [current]') : '';
+                    console.log(`  ${chalk.cyan(`${i + 1}.`)} ${chalk.white(p.name)}${date}${currentTag}`);
+                    if (p.brief)
+                        console.log(`     ${chalk.dim(p.brief)}`);
+                });
+                console.log();
+                const defaultHint = currentIndex >= 0
+                    ? ` (Enter keeps ${products[currentIndex].name})`
+                    : '';
+                const answer = await prompt(chalk.cyan(`  Select a product number${defaultHint}: `));
+                const choice = parseInt(answer, 10);
+                if (!answer && currentIndex >= 0) {
+                    selected = products[currentIndex];
+                }
+                else if (Number.isFinite(choice) && choice >= 1 && choice <= products.length) {
+                    selected = products[choice - 1];
+                }
+                else if (currentIndex >= 0) {
+                    selected = products[currentIndex];
+                    console.log(chalk.yellow(`  Invalid selection. Keeping "${selected.name}".`));
+                }
+                else {
+                    selected = products[0];
+                    console.log(chalk.yellow(`  Invalid selection. Defaulting to "${selected.name}".`));
+                }
+            }
+            else {
+                selected = currentIndex >= 0 ? products[currentIndex] : products[0];
+                if (currentIndex < 0) {
+                    console.log(chalk.dim(`  Auto-selected product: ${selected.name}`));
+                }
+            }
+            const changed = selected.id !== config?.product_id || selected.name !== config?.product_name;
+            if (changed) {
+                const configPath = writeCutlineConfig(projectRoot, {
+                    product_id: selected.id,
+                    product_name: selected.name,
+                    linked_email: auth.email ?? null,
+                });
+                console.log(chalk.green(`  ✓ Normalized product to "${selected.name}"`));
+                console.log(chalk.dim(`    ${configPath}`));
+            }
+            config = {
+                product_id: selected.id,
+                product_name: selected.name,
+                linked_email: auth.email ?? config?.linked_email ?? null,
+            };
+            console.log();
+        }
+        else if (requestOk) {
+            console.log(chalk.yellow('  No completed product graphs found for this premium account.'));
+            console.log(chalk.dim('  Generate a deep dive first, then re-run cutline-mcp init for normalization.\n'));
+        }
+        else {
+            console.log(chalk.yellow('  Could not fetch products for normalization (network/auth issue).'));
+            console.log(chalk.dim('  Continuing with existing .cutline/config.json values.\n'));
+        }
+    }
     if (config) {
         console.log(chalk.dim(`  Product: ${config.product_name ?? config.product_id}`));
     }

package/dist/commands/serve.js

@@ -12,6 +12,18 @@ const SERVER_MAP = {
     output: 'output-server.js',
     integrations: 'integrations-server.js',
 };
+function handleChildMessage(message, pending) {
+    const parsed = message;
+    const id = normalizeId(parsed?.id);
+    if (!id)
+        return;
+    const entry = pending.get(id);
+    if (!entry)
+        return;
+    clearTimeout(entry.timer);
+    pending.delete(id);
+    entry.resolve(message);
+}
 function readJsonBody(req) {
     return new Promise((resolveBody, rejectBody) => {
         const chunks = [];
@@ -77,44 +89,68 @@ function serveHttpBridge(serverName, serverPath, opts) {
         if (!child.stdin || child.killed) {
             throw new Error('MCP stdio server is not available');
         }
-        const body = JSON.stringify(message);
-        const packet = `Content-Length: ${Buffer.byteLength(body, 'utf8')}\r\n\r\n${body}`;
-        child.stdin.write(packet, 'utf8');
+        // Our bundled servers (MCP SDK 1.x) use line-delimited JSON over stdio.
+        // Write one JSON-RPC envelope per line.
+        const line = `${JSON.stringify(message)}\n`;
+        child.stdin.write(line, 'utf8');
     };
     child.stdout?.on('data', (chunk) => {
         stdoutBuffer = Buffer.concat([stdoutBuffer, chunk]);
+        // 1) Support MCP framed responses (Content-Length) for compatibility.
         while (true) {
-            const separatorIndex = stdoutBuffer.indexOf('\r\n\r\n');
+            const crlfSeparator = stdoutBuffer.indexOf('\r\n\r\n');
+            const lfSeparator = stdoutBuffer.indexOf('\n\n');
+            let separatorIndex = -1;
+            let separatorLength = 0;
+            if (crlfSeparator >= 0 && (lfSeparator < 0 || crlfSeparator < lfSeparator)) {
+                separatorIndex = crlfSeparator;
+                separatorLength = 4;
+            }
+            else if (lfSeparator >= 0) {
+                separatorIndex = lfSeparator;
+                separatorLength = 2;
+            }
             if (separatorIndex < 0)
                 break;
             const headers = stdoutBuffer.slice(0, separatorIndex).toString('utf8');
             const lengthMatch = headers.match(/content-length:\s*(\d+)/i);
-            if (!lengthMatch) {
-                stdoutBuffer = stdoutBuffer.slice(separatorIndex + 4);
-                continue;
-            }
+            if (!lengthMatch)
+                break;
             const contentLength = Number(lengthMatch[1]);
-            const packetLength = separatorIndex + 4 + contentLength;
+            const packetLength = separatorIndex + separatorLength + contentLength;
             if (stdoutBuffer.length < packetLength)
                 break;
-            const jsonBytes = stdoutBuffer.slice(separatorIndex + 4, packetLength);
+            const jsonBytes = stdoutBuffer.slice(separatorIndex + separatorLength, packetLength);
             stdoutBuffer = stdoutBuffer.slice(packetLength);
             try {
                 const message = JSON.parse(jsonBytes.toString('utf8'));
-                const id = normalizeId(message?.id);
-                if (!id)
-                    continue;
-                const entry = pending.get(id);
-                if (!entry)
-                    continue;
-                clearTimeout(entry.timer);
-                pending.delete(id);
-                entry.resolve(message);
+                handleChildMessage(message, pending);
             }
             catch {
                 // Ignore malformed child output and keep processing subsequent frames.
             }
         }
+        // 2) Support line-delimited JSON responses used by our bundled servers.
+        const head = stdoutBuffer.slice(0, Math.min(stdoutBuffer.length, 32)).toString('utf8');
+        const looksLikeFramedPrefix = /^\s*content-length\s*:/i.test(head);
+        if (!looksLikeFramedPrefix) {
+            const text = stdoutBuffer.toString('utf8');
+            const lines = text.split(/\r?\n/);
+            const remainder = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                try {
+                    const message = JSON.parse(trimmed);
+                    handleChildMessage(message, pending);
+                }
+                catch {
+                    // Ignore non-JSON stdout lines (if any).
+                }
+            }
+            stdoutBuffer = Buffer.from(remainder, 'utf8');
+        }
     });
     child.on('exit', (code, signal) => {
         failAllPending(new Error(`MCP stdio server exited unexpectedly (${signal ? `signal ${signal}` : `code ${code ?? 'unknown'}`})`));

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.7.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",