@vibekiln/cutline-mcp-cli 0.4.4 → 0.6.0

package/README.md

@@ -135,6 +135,19 @@ cutline-mcp serve output         # Export and rendering
 cutline-mcp serve integrations   # External integrations
 ```
 
+HTTP bridge mode (for registries/hosts that require an HTTPS MCP URL):
+
+```bash
+cutline-mcp serve constraints --http --host 0.0.0.0 --port 8080 --path /mcp
+# Health: GET /health
+# MCP endpoint: POST /mcp
+```
+
+Bridge notes:
+- Default mode remains stdio (no behavior change for Cursor/Claude Desktop local configs).
+- The bridge forwards JSON-RPC requests to the bundled stdio server process.
+- Batch JSON-RPC payloads are not supported by the bridge.
+
 ### `upgrade`
 
 Open the upgrade page and refresh your session.
@@ -206,6 +219,10 @@ Config: [`server.json`](./server.json)
 
 Config: [`smithery.yaml`](./smithery.yaml) with [`Dockerfile`](./Dockerfile)
 
+If the publish UI requires an MCP Server URL, deploy the bridge and provide your public HTTPS endpoint, for example:
+
+`https://mcp.thecutline.ai/mcp`
+
 ### Claude Desktop Extension
 
 ```bash

package/dist/commands/serve.d.ts

@@ -1 +1,8 @@
-export declare function serveCommand(serverName: string): void;
+interface ServeOptions {
+    http?: boolean;
+    host?: string;
+    port?: string;
+    path?: string;
+}
+export declare function serveCommand(serverName: string, options?: ServeOptions): void;
+export {};

package/dist/commands/serve.js

@@ -1,4 +1,5 @@
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawn } from 'node:child_process';
+import { createServer } from 'node:http';
 import { resolve, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { existsSync } from 'node:fs';
@@ -11,7 +12,174 @@ const SERVER_MAP = {
     output: 'output-server.js',
     integrations: 'integrations-server.js',
 };
-export function serveCommand(serverName) {
+function readJsonBody(req) {
+    return new Promise((resolveBody, rejectBody) => {
+        const chunks = [];
+        let total = 0;
+        const MAX_BODY_BYTES = 1024 * 1024; // 1MB safety cap
+        req.on('data', (chunk) => {
+            total += chunk.length;
+            if (total > MAX_BODY_BYTES) {
+                rejectBody(new Error('Request body too large'));
+                req.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => {
+            try {
+                const text = Buffer.concat(chunks).toString('utf8');
+                resolveBody(text ? JSON.parse(text) : {});
+            }
+            catch {
+                rejectBody(new Error('Invalid JSON body'));
+            }
+        });
+        req.on('error', rejectBody);
+    });
+}
+function writeJson(res, statusCode, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(statusCode, {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload),
+    });
+    res.end(payload);
+}
+function normalizeId(id) {
+    if (typeof id === 'string' || typeof id === 'number')
+        return String(id);
+    return '';
+}
+function serveHttpBridge(serverName, serverPath, opts) {
+    const host = opts.host || process.env.CUTLINE_MCP_HTTP_HOST || '0.0.0.0';
+    const port = Number(opts.port || process.env.CUTLINE_MCP_HTTP_PORT || '8080');
+    const mcpPath = opts.path || process.env.CUTLINE_MCP_HTTP_PATH || '/mcp';
+    const requestTimeoutMs = Number(process.env.CUTLINE_MCP_HTTP_TIMEOUT_MS || '30000');
+    if (!Number.isFinite(port) || port <= 0) {
+        console.error(`Invalid --port value: ${opts.port}`);
+        process.exit(1);
+    }
+    const child = spawn(process.execPath, [serverPath], {
+        stdio: ['pipe', 'pipe', 'inherit'],
+        env: process.env,
+    });
+    const pending = new Map();
+    let stdoutBuffer = Buffer.alloc(0);
+    const failAllPending = (reason) => {
+        for (const [key, entry] of pending.entries()) {
+            clearTimeout(entry.timer);
+            entry.reject(reason);
+            pending.delete(key);
+        }
+    };
+    const sendToStdioServer = (message) => {
+        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');
+    };
+    child.stdout?.on('data', (chunk) => {
+        stdoutBuffer = Buffer.concat([stdoutBuffer, chunk]);
+        while (true) {
+            const separatorIndex = stdoutBuffer.indexOf('\r\n\r\n');
+            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;
+            }
+            const contentLength = Number(lengthMatch[1]);
+            const packetLength = separatorIndex + 4 + contentLength;
+            if (stdoutBuffer.length < packetLength)
+                break;
+            const jsonBytes = stdoutBuffer.slice(separatorIndex + 4, 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);
+            }
+            catch {
+                // Ignore malformed child output and keep processing subsequent frames.
+            }
+        }
+    });
+    child.on('exit', (code, signal) => {
+        failAllPending(new Error(`MCP stdio server exited unexpectedly (${signal ? `signal ${signal}` : `code ${code ?? 'unknown'}`})`));
+    });
+    const httpServer = createServer(async (req, res) => {
+        const { method } = req;
+        const reqPath = (req.url || '/').split('?')[0];
+        if (method === 'GET' && reqPath === '/health') {
+            writeJson(res, 200, {
+                ok: true,
+                server: serverName,
+                transport: 'http-bridge-stdio',
+                mcp_path: mcpPath,
+            });
+            return;
+        }
+        if (method !== 'POST' || reqPath !== mcpPath) {
+            writeJson(res, 404, { error: `Not found. Use POST ${mcpPath}` });
+            return;
+        }
+        try {
+            const body = await readJsonBody(req);
+            if (Array.isArray(body)) {
+                writeJson(res, 400, { error: 'Batch JSON-RPC is not supported by this bridge' });
+                return;
+            }
+            const message = body;
+            const id = normalizeId(message?.id);
+            // Notifications do not have an id and do not expect a response.
+            if (!id) {
+                sendToStdioServer(message);
+                writeJson(res, 202, { ok: true });
+                return;
+            }
+            const response = await new Promise((resolveResponse, rejectResponse) => {
+                const timer = setTimeout(() => {
+                    pending.delete(id);
+                    rejectResponse(new Error(`Timed out waiting for response id=${id}`));
+                }, requestTimeoutMs);
+                pending.set(id, {
+                    resolve: resolveResponse,
+                    reject: rejectResponse,
+                    timer,
+                });
+                try {
+                    sendToStdioServer(message);
+                }
+                catch (error) {
+                    clearTimeout(timer);
+                    pending.delete(id);
+                    rejectResponse(error);
+                }
+            });
+            writeJson(res, 200, response);
+        }
+        catch (error) {
+            writeJson(res, 500, { error: error?.message || 'Bridge request failed' });
+        }
+    });
+    httpServer.listen(port, host, () => {
+        console.error(`Cutline MCP HTTP bridge listening on http://${host}:${port}${mcpPath}`);
+        console.error(`Health check: http://${host}:${port}/health`);
+    });
+}
+export function serveCommand(serverName, options = {}) {
     const fileName = SERVER_MAP[serverName];
     if (!fileName) {
         const valid = Object.keys(SERVER_MAP).join(', ');
@@ -24,8 +192,11 @@ export function serveCommand(serverName) {
         console.error('The package may not have been built correctly.');
         process.exit(1);
     }
-    // Replace this process with the MCP server.
-    // MCP servers use stdio transport, so we need to keep stdin/stdout connected.
+    if (options.http) {
+        serveHttpBridge(serverName, serverPath, options);
+        return;
+    }
+    // Replace this process with the MCP server (default stdio mode).
     try {
         execFileSync(process.execPath, [serverPath], {
             stdio: 'inherit',

package/dist/index.js

@@ -47,7 +47,16 @@ program
 program
     .command('serve <server>')
     .description('Start an MCP server (constraints, premortem, exploration, tools, output, integrations)')
-    .action(serveCommand);
+    .option('--http', 'Expose the selected stdio server over an HTTP bridge')
+    .option('--host <host>', 'HTTP bind host for bridge mode (default: 0.0.0.0)')
+    .option('--port <port>', 'HTTP port for bridge mode (default: 8080)')
+    .option('--path <path>', 'HTTP MCP path for bridge mode (default: /mcp)')
+    .action((server, opts) => serveCommand(server, {
+    http: opts.http,
+    host: opts.host,
+    port: opts.port,
+    path: opts.path,
+}));
 program
     .command('setup')
     .description('One-command onboarding: authenticate, write IDE MCP config, generate rules')

package/dist/servers/cutline-server.js

@@ -7408,6 +7408,146 @@ var ACT_NAMES = {
   5: "Value Ranking",
   6: "Graduation"
 };
+function assessScopeExpansionIntent(params) {
+  const task = (params.task_description || "").trim();
+  const filePaths = params.file_paths || [];
+  const reasons = [];
+  let confidence = 0;
+  const explicitScopePatterns = [
+    /\b(scope increase|expand(?:ing)? scope|broaden scope|new scope)\b/i,
+    /\b(seed|ingest|add)\b.{0,24}\b(graph|constraint|entity|entities)\b/i,
+    /\b(new feature|new module|new domain|new subsystem)\b/i
+  ];
+  const hasExplicitScopeIntent = explicitScopePatterns.some((rx) => rx.test(task));
+  if (hasExplicitScopeIntent) {
+    confidence += 0.55;
+    reasons.push("Task description includes explicit scope-expansion language.");
+  }
+  const hintedName = params.hinted_entity_name?.trim();
+  const inferredName = hintedName || inferEntityNameFromTask(task);
+  if (inferredName) {
+    confidence += 0.12;
+    reasons.push("Potential new entity name detected from task context.");
+  }
+  if (filePaths.length > 0) {
+    const dirHints = new Set(filePaths.map((p) => p.split("/").filter(Boolean)).filter((parts) => parts.length > 1).map((parts) => parts[parts.length - 2].toLowerCase()).filter((v) => v.length >= 3));
+    if (dirHints.size >= 2) {
+      confidence += 0.08;
+      reasons.push("Multiple code areas touched, indicating potential boundary expansion.");
+    }
+  }
+  if (inferredName && params.known_entity_names?.length) {
+    const norm = normalizeName(inferredName);
+    const known = params.known_entity_names.some((n) => normalizeName(n) === norm);
+    if (!known) {
+      confidence += 0.25;
+      reasons.push("Entity candidate does not match existing graph entities.");
+    } else {
+      confidence -= 0.1;
+      reasons.push("Entity candidate already exists in graph.");
+    }
+  }
+  confidence = Math.max(0, Math.min(1, confidence));
+  const triggered = confidence >= 0.6 || hasExplicitScopeIntent;
+  const recommended_tool_calls = triggered ? [
+    "constraints_learn(product_id, name, entity_type, description, ...)",
+    "graph_bind_codebase(product_id, file_paths)",
+    "graph_bind_confirm(product_id, entity_id, file_patterns)",
+    "graph_metrics(product_id)"
+  ] : [];
+  return {
+    triggered,
+    confidence: Math.round(confidence * 100) / 100,
+    reasons,
+    candidate_name: inferredName,
+    recommended_tool_calls
+  };
+}
+function inferEntityNameFromTask(task) {
+  if (!task)
+    return void 0;
+  const match = task.match(/\b(?:add|build|create|introduce|expand(?:ing)?\s+scope(?:\s+for|\s+to)?)\s+(?:a|an|the)?\s*([a-zA-Z0-9][a-zA-Z0-9 _-]{2,60})/i);
+  if (!match?.[1])
+    return void 0;
+  const candidate = match[1].trim().replace(/\s{2,}/g, " ");
+  if (candidate.length < 3)
+    return void 0;
+  return candidate;
+}
+function normalizeName(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+}
+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);
+  const entityId = `${entity_type}:${slug}`;
+  const now = /* @__PURE__ */ new Date();
+  const entity = {
+    id: entityId,
+    type: entity_type,
+    name: name2,
+    aliases: tags ?? [],
+    description,
+    source_id: "ide",
+    source_type: "ide",
+    ingested_at: now
+  };
+  await addEntity(product_id, entity);
+  if (parent_id) {
+    const edgeType = entity_type === "component" ? "REQUIRES" : "DEPENDS_ON";
+    await addEdges(product_id, [{
+      id: `edge:auto_scope:${parent_id}:${entityId}`,
+      source_id: parent_id,
+      source_type: "feature",
+      target_id: entityId,
+      target_type: entity_type,
+      edge_type: edgeType
+    }]);
+  }
+  let embeddingGenerated = false;
+  try {
+    const embedding = await generateEntityEmbedding(entity);
+    if (embedding.some((v) => v !== 0)) {
+      await updateEntityEmbedding(product_id, entityId, embedding);
+      entity.embedding = embedding;
+      embeddingGenerated = true;
+    }
+  } catch {
+  }
+  const similar = embeddingGenerated ? await findSimilarEntities(product_id, entity, {
+    threshold: similarity_threshold ?? 0.65
+  }) : [];
+  let propagatedCount = 0;
+  for (const match of similar) {
+    const propagated = await propagateConstraints(product_id, match.entity.id, entityId, match.similarity);
+    propagatedCount += propagated.length;
+  }
+  try {
+    const [entities, edges, constraints, bindings] = await Promise.all([
+      getAllEntities(product_id),
+      getAllEdges(product_id),
+      getAllNodes(product_id),
+      getAllBindings(product_id)
+    ]);
+    const metrics = computeMetricsFromGraph(entities, edges, constraints, bindings);
+    await updateGraphMetadata(product_id, {
+      last_build: now,
+      entity_count: entities.length,
+      edge_count: edges.length,
+      constraint_count: constraints.length,
+      binding_count: bindings.length,
+      sources: ["ide", "deep_dive_pipeline"],
+      metrics
+    });
+    await recordScoreSnapshot(product_id, metrics, "constraint_learn", name2);
+  } catch {
+  }
+  return {
+    entity_id: entityId,
+    propagated_count: propagatedCount,
+    similar_count: similar.length
+  };
+}
 var server = new Server({
   name: "cutline",
   version: "0.2.0"
@@ -7862,7 +8002,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             max_constraints: { type: "number", description: "Max constraints to return (default: 5)" },
             use_semantic: { type: "boolean", description: "Use semantic search if embeddings available (default: true)" },
-            phase: { type: "string", enum: ["test_spec", "functional", "security", "performance", "economics", "full", "auto"], description: "RGR phase filter. 'auto' uses complexity heuristic. Default: 'full'" }
+            phase: { type: "string", enum: ["test_spec", "functional", "security", "performance", "economics", "full", "auto"], description: "RGR phase filter. 'auto' uses complexity heuristic. Default: 'full'" },
+            auto_scope_expand: { type: "boolean", description: "If true, auto-seed a new graph entity when scope expansion intent is confidently detected and entity fields are provided." },
+            scope_entity_name: { type: "string", description: "Optional explicit entity name to seed during scope expansion (for example 'Vibe Check Extension')." },
+            scope_entity_type: { type: "string", enum: ["feature", "component", "data_type"], description: "Entity type for auto scope expansion." },
+            scope_entity_description: { type: "string", description: "1-2 sentence description of the new entity to seed." },
+            scope_entity_tags: { type: "array", items: { type: "string" }, description: "Optional tags/aliases for the new entity." },
+            scope_parent_id: { type: "string", description: "Optional parent graph entity ID for linking this scope expansion." },
+            scope_similarity_threshold: { type: "number", description: "Optional similarity threshold for propagated constraints (default: 0.65)." }
           },
           required: ["product_id"]
         }
@@ -9035,7 +9182,7 @@ Meta: ${JSON.stringify(output.meta)}` }
             return void 0;
           };
           var detectFramework = detectFramework2;
-          const { product_id, file_paths, code_snippet, task_description, mode = "auto", max_constraints = 5, use_semantic = true, phase: autoPhase = "full" } = args;
+          const { product_id, file_paths, code_snippet, task_description, mode = "auto", max_constraints = 5, use_semantic = true, phase: autoPhase = "full", auto_scope_expand = false, scope_entity_name, scope_entity_type, scope_entity_description, scope_entity_tags, scope_parent_id, scope_similarity_threshold } = args;
           if (!product_id) {
             throw new McpError(ErrorCode.InvalidParams, "product_id is required");
           }
@@ -9061,6 +9208,34 @@ Meta: ${JSON.stringify(output.meta)}` }
             };
           }
           const analysis = analyzeFileContext(fileContext);
+          let knownEntityNames = [];
+          if (task_description || scope_entity_name) {
+            try {
+              const entities = await getAllEntities(product_id);
+              knownEntityNames = entities.map((e) => e.name);
+            } catch {
+            }
+          }
+          const scopeExpansion = assessScopeExpansionIntent({
+            task_description,
+            file_paths,
+            known_entity_names: knownEntityNames,
+            hinted_entity_name: scope_entity_name
+          });
+          let scopeSeedResult;
+          const hasSeedPayload = !!scope_entity_name && !!scope_entity_type && !!scope_entity_description;
+          const shouldAutoSeed = auto_scope_expand && scopeExpansion.triggered && hasSeedPayload;
+          if (shouldAutoSeed) {
+            scopeSeedResult = await seedScopeEntityFromAuto({
+              product_id,
+              name: scope_entity_name,
+              entity_type: scope_entity_type,
+              description: scope_entity_description,
+              parent_id: scope_parent_id,
+              tags: scope_entity_tags,
+              similarity_threshold: scope_similarity_threshold
+            });
+          }
           const actualMode = mode === "auto" ? analysis.suggested_mode : mode;
           if (actualMode === "silent") {
             return {
@@ -9074,7 +9249,9 @@ Meta: ${JSON.stringify(output.meta)}` }
                     mode: "silent",
                     detected_domains: analysis.detected_domains,
                     signal_strength: Math.round(analysis.confidence * 100) / 100,
-                    keywords_detected: analysis.signal.keywords?.slice(0, 5)
+                    keywords_detected: analysis.signal.keywords?.slice(0, 5),
+                    scope_expansion: scopeExpansion,
+                    scope_seeded: scopeSeedResult || void 0
                   }
                 })
               }]
@@ -9229,6 +9406,12 @@ Meta: ${JSON.stringify(output.meta)}` }
    \u2192 You may need to prioritize one over the other.`;
               }).join("\n\n");
             }
+            if (scopeExpansion.triggered) {
+              const recommendation = shouldAutoSeed ? `\u2705 Scope expansion detected and entity seeded: ${scopeSeedResult?.entity_id ?? "(created)"}` : `\u{1F9ED} Scope expansion detected. Recommended next tool: constraints_learn(...)`;
+              humanReadable += `
+
+${recommendation}`;
+            }
           }
           return {
             content: [{
@@ -9249,7 +9432,9 @@ Meta: ${JSON.stringify(output.meta)}` }
                   used_semantic: use_semantic && finalResults.some((r) => r.match_type === "semantic" || r.match_type === "hybrid"),
                   used_category_prefilter: usePreFilter,
                   phase: autoPhase,
-                  rgr_plan: autoRgrPlan || void 0
+                  rgr_plan: autoRgrPlan || void 0,
+                  scope_expansion: scopeExpansion,
+                  scope_seeded: scopeSeedResult || void 0
                 }
               })
             }]

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vibekiln/cutline-mcp-cli",
-    "version": "0.4.4",
+    "version": "0.6.0",
     "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",