@kylewadegrove/cutline-mcp-cli 0.6.0 → 0.6.1

package/dist/servers/chunk-PQUAX5YW.js

@@ -0,0 +1,464 @@
+import {
+  getStoredToken
+} from "./chunk-NUBIEJTU.js";
+
+// ../mcp/dist/mcp/src/data-client.js
+function getBaseUrl(environment) {
+  return environment === "staging" ? "https://us-central1-cutline-staging.cloudfunctions.net" : "https://us-central1-cutline-prod.cloudfunctions.net";
+}
+var cachedBaseUrl;
+var cachedIdToken;
+var tokenExpiresAt = 0;
+var FIREBASE_API_KEY_CACHE = {};
+async function getFirebaseApiKey(environment) {
+  const envKey = process.env.FIREBASE_API_KEY || process.env.NEXT_PUBLIC_FIREBASE_API_KEY;
+  if (envKey)
+    return envKey;
+  if (FIREBASE_API_KEY_CACHE.key && FIREBASE_API_KEY_CACHE.env === environment && FIREBASE_API_KEY_CACHE.at && Date.now() - FIREBASE_API_KEY_CACHE.at < 36e5) {
+    return FIREBASE_API_KEY_CACHE.key;
+  }
+  const baseUrl = environment === "staging" ? "https://cutline-staging.web.app" : "https://thecutline.ai";
+  const res = await fetch(`${baseUrl}/api/firebase-config`, {
+    headers: { Accept: "application/json" },
+    signal: AbortSignal.timeout(5e3)
+  });
+  if (!res.ok)
+    throw new Error(`Failed to fetch firebase config: HTTP ${res.status}`);
+  const data = await res.json();
+  if (!data.apiKey)
+    throw new Error("No apiKey in firebase-config response");
+  FIREBASE_API_KEY_CACHE.key = data.apiKey;
+  FIREBASE_API_KEY_CACHE.env = environment;
+  FIREBASE_API_KEY_CACHE.at = Date.now();
+  return data.apiKey;
+}
+async function exchangeRefreshForId(refreshToken, environment) {
+  const apiKey = await getFirebaseApiKey(environment);
+  const res = await fetch(`https://securetoken.googleapis.com/v1/token?key=${apiKey}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ grant_type: "refresh_token", refresh_token: refreshToken }),
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(`Token exchange failed: ${err?.error?.message || res.status}`);
+  }
+  const data = await res.json();
+  return data.id_token;
+}
+async function resolveAuth() {
+  if (cachedIdToken && Date.now() < tokenExpiresAt && cachedBaseUrl) {
+    return { baseUrl: cachedBaseUrl, idToken: cachedIdToken };
+  }
+  const stored = await getStoredToken();
+  if (!stored) {
+    throw new Error("Not authenticated. Run 'cutline-mcp login' first.");
+  }
+  const env = stored.environment || "production";
+  const baseUrl = getBaseUrl(env);
+  const idToken = await exchangeRefreshForId(stored.refreshToken, env);
+  cachedBaseUrl = baseUrl;
+  cachedIdToken = idToken;
+  tokenExpiresAt = Date.now() + 50 * 60 * 1e3;
+  return { baseUrl, idToken };
+}
+async function proxy(action, params = {}) {
+  const { baseUrl, idToken } = await resolveAuth();
+  const res = await fetch(`${baseUrl}/mcpDataProxy`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${idToken}`
+    },
+    body: JSON.stringify({ action, params }),
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (!res.ok) {
+    if (res.status === 401) {
+      cachedIdToken = void 0;
+      tokenExpiresAt = 0;
+      throw new Error("Authentication expired \u2014 retrying on next call");
+    }
+    const body = await res.text().catch(() => "");
+    throw new Error(`mcpDataProxy ${action} failed (${res.status}): ${body.slice(0, 200)}`);
+  }
+  return res.json();
+}
+async function listPremortems(opts) {
+  const res = await proxy("premortem.list", opts || {});
+  return res.docs;
+}
+async function getPremortem(id) {
+  const res = await proxy("premortem.get", { id });
+  return res.doc;
+}
+async function createPremortem(data, id) {
+  return proxy("premortem.create", { data, id });
+}
+async function updatePremortem(id, data) {
+  return proxy("premortem.update", { id, data });
+}
+async function getIdeaReport(id) {
+  const res = await proxy("premortem.getIdea", { id });
+  return res.doc;
+}
+async function saveChat(id, data) {
+  return proxy("chat.save", { id, data });
+}
+async function getChat(id) {
+  const res = await proxy("chat.get", { id });
+  return res.doc;
+}
+async function updateChat(id, data) {
+  return proxy("chat.update", { id, data });
+}
+async function createExplorationSession(id, data, collection) {
+  return proxy("exploration.create", { id, data, collection });
+}
+async function getExplorationSession(id, collection) {
+  const res = await proxy("exploration.get", { id, collection });
+  return res.doc;
+}
+async function updateExplorationSession(id, data, collection) {
+  return proxy("exploration.update", { id, data, collection });
+}
+async function listExplorationSessions(collection, limit) {
+  const res = await proxy("exploration.list", { collection, limit });
+  return res.docs;
+}
+async function getAllEntities(productId) {
+  const res = await proxy("graph.getEntities", { productId });
+  return res.docs.map((d) => ({ ...d, ingested_at: new Date(d.ingested_at?._seconds ? d.ingested_at._seconds * 1e3 : d.ingested_at) }));
+}
+async function upsertEntities(productId, _sourceType, _sourceId, entities) {
+  await proxy("graph.upsertEntities", { productId, entities: entities.map((e) => ({ ...e, ingested_at: e.ingested_at?.toISOString?.() ?? e.ingested_at })) });
+}
+async function addEntity(productId, entity) {
+  await proxy("graph.upsertEntities", { productId, entities: [{ ...entity, ingested_at: entity.ingested_at?.toISOString?.() ?? entity.ingested_at }] });
+}
+async function getEntityById(productId, entityId) {
+  const all = await getAllEntities(productId);
+  return all.find((e) => e.id === entityId) ?? null;
+}
+async function getEntitiesWithEmbeddings(productId) {
+  const all = await getAllEntities(productId);
+  return all.filter((e) => e.embedding && e.embedding.length > 0);
+}
+async function updateEntityEmbedding(productId, entityId, embedding) {
+  await proxy("graph.updateEmbedding", { productId, collection: "entities", docId: entityId, embedding });
+}
+async function getAllEdges(productId) {
+  const res = await proxy("graph.getEdges", { productId });
+  return res.docs;
+}
+async function upsertEdges(productId, _sourceId, edges) {
+  await proxy("graph.upsertEdges", { productId, edges });
+}
+async function addEdges(productId, edges) {
+  await proxy("graph.upsertEdges", { productId, edges });
+}
+async function getAllBindings(productId) {
+  const res = await proxy("graph.getBindings", { productId });
+  return res.docs;
+}
+async function getBindingsForEntity(productId, entityId) {
+  const res = await proxy("graph.getBindings", { productId, entityId });
+  return res.docs;
+}
+async function upsertBindings(productId, bindings) {
+  await proxy("graph.upsertBindings", { productId, bindings });
+}
+async function deleteBinding(productId, bindingId) {
+  await proxy("graph.upsertBindings", { productId, deleteIds: [bindingId] });
+}
+var NODE_CACHE_TTL = 10 * 60 * 1e3;
+var nodeCache = /* @__PURE__ */ new Map();
+var lightNodeCache = /* @__PURE__ */ new Map();
+function invalidateNodeCache(productId) {
+  nodeCache.delete(productId);
+  lightNodeCache.delete(productId);
+}
+async function getAllNodes(productId) {
+  const cached = nodeCache.get(productId);
+  if (cached && Date.now() - cached.fetchedAt < NODE_CACHE_TTL)
+    return cached.nodes;
+  const res = await proxy("graph.getNodes", { productId });
+  const nodes = res.docs.map((d) => ({
+    ...d,
+    ingested_at: new Date(d.ingested_at?._seconds ? d.ingested_at._seconds * 1e3 : d.ingested_at)
+  }));
+  nodeCache.set(productId, { nodes, fetchedAt: Date.now() });
+  return nodes;
+}
+async function getAllNodesLight(productId) {
+  const cached = lightNodeCache.get(productId);
+  if (cached && Date.now() - cached.fetchedAt < NODE_CACHE_TTL)
+    return cached.nodes;
+  const res = await proxy("graph.getNodes", { productId, light: true });
+  const nodes = res.docs.map((d) => ({
+    ...d,
+    ingested_at: new Date(d.ingested_at?._seconds ? d.ingested_at._seconds * 1e3 : d.ingested_at)
+  }));
+  lightNodeCache.set(productId, { nodes, fetchedAt: Date.now() });
+  return nodes;
+}
+async function getNodesByCategories(productId, categories) {
+  const res = await proxy("graph.getNodes", { productId, categories: categories.slice(0, 10) });
+  return res.docs.map((d) => ({
+    ...d,
+    ingested_at: new Date(d.ingested_at?._seconds ? d.ingested_at._seconds * 1e3 : d.ingested_at)
+  }));
+}
+async function getNodesBySource(productId, sourceType) {
+  const res = await proxy("graph.getNodes", { productId, sourceType });
+  return res.docs.map((d) => ({
+    ...d,
+    ingested_at: new Date(d.ingested_at?._seconds ? d.ingested_at._seconds * 1e3 : d.ingested_at)
+  }));
+}
+async function upsertNodes(productId, _sourceType, _sourceId, nodes) {
+  await proxy("graph.upsertNodes", { productId, nodes: nodes.map((n) => ({ ...n, ingested_at: n.ingested_at?.toISOString?.() ?? n.ingested_at })) });
+  invalidateNodeCache(productId);
+}
+async function addNodes(productId, nodes) {
+  await proxy("graph.upsertNodes", { productId, nodes: nodes.map((n) => ({ ...n, ingested_at: n.ingested_at?.toISOString?.() ?? n.ingested_at })) });
+  invalidateNodeCache(productId);
+}
+async function deleteAllNodes(productId) {
+  await proxy("graph.deleteAll", { productId });
+  invalidateNodeCache(productId);
+}
+async function hasConstraints(productId) {
+  const res = await proxy("graph.hasConstraints", { productId });
+  return res.hasConstraints;
+}
+async function searchNodesByKeywords(productId, keywords) {
+  const allNodes = await getAllNodes(productId);
+  const lowerKeywords = keywords.map((k) => k.toLowerCase());
+  return allNodes.filter((node) => {
+    const nodeKeywords = (node.keywords || []).map((k) => k.toLowerCase());
+    return lowerKeywords.some((kw) => nodeKeywords.some((nk) => nk.includes(kw) || kw.includes(nk)));
+  });
+}
+async function getNodesWithEmbeddings(productId) {
+  const all = await getAllNodes(productId);
+  return all.filter((n) => n.embedding && n.embedding.length > 0);
+}
+async function getNodesMissingEmbeddings(productId) {
+  const all = await getAllNodes(productId);
+  return all.filter((n) => !n.embedding || n.embedding.length === 0);
+}
+async function updateNodeEmbeddings(productId, updates) {
+  for (const { id, embedding } of updates) {
+    await proxy("graph.updateEmbedding", { productId, collection: "nodes", docId: id, embedding });
+  }
+  invalidateNodeCache(productId);
+}
+async function addTestCases(productId, cases) {
+  await proxy("graph.addTestCases", { productId, testCases: cases });
+}
+async function getTestCasesForEntity(productId, entityId) {
+  const res = await proxy("graph.getTestCases", { productId, entityId });
+  return res.docs;
+}
+async function getTestCasesForProduct(productId) {
+  const res = await proxy("graph.getTestCases", { productId });
+  return res.docs;
+}
+async function getGraphMetadata(productId) {
+  const res = await proxy("graph.getMeta", { productId });
+  if (!res.doc)
+    return null;
+  const data = res.doc;
+  return { ...data, last_build: new Date(data.last_build?._seconds ? data.last_build._seconds * 1e3 : data.last_build ?? Date.now()) };
+}
+async function updateGraphMetadata(productId, meta) {
+  const payload = { ...meta };
+  if (meta.last_build instanceof Date) {
+    payload.last_build = meta.last_build.toISOString();
+  }
+  await proxy("graph.updateMeta", { productId, data: payload });
+}
+async function recordScoreSnapshot(productId, metrics, event, _eventDetail) {
+  try {
+    const snapshot = {
+      engineering_readiness_pct: Math.round(metrics.engineering_readiness_pct ?? 0),
+      security_readiness_pct: Math.round(metrics.security_readiness_pct ?? 0),
+      reliability_readiness_pct: Math.round(metrics.reliability_readiness_pct ?? 0),
+      scalability_readiness_pct: Math.round(metrics.scalability_readiness_pct ?? 0),
+      nfr_coverage_pct: Math.round((metrics.nfr_coverage?.overall ?? 0) * 100),
+      speedup_factor: metrics.time_estimate?.speedup_factor ?? 1,
+      event,
+      ..._eventDetail ? { event_detail: _eventDetail } : {},
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const snapshotId = `score_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
+    const prefix = "result.decision.productionalization_feasibility";
+    const jobUpdate = {
+      [`${prefix}.engineering_readiness_pct`]: snapshot.engineering_readiness_pct,
+      [`${prefix}.security_readiness_pct`]: snapshot.security_readiness_pct,
+      [`${prefix}.reliability_readiness_pct`]: snapshot.reliability_readiness_pct,
+      [`${prefix}.scalability_readiness_pct`]: snapshot.scalability_readiness_pct,
+      [`${prefix}.nfr_coverage_pct`]: snapshot.nfr_coverage_pct
+    };
+    await proxy("graph.recordScore", { productId, snapshotId, snapshot, jobUpdate });
+  } catch (err) {
+    console.error("[score-history] Failed to record snapshot:", err.message);
+  }
+}
+async function deleteGraphData(productId) {
+  await proxy("graph.deleteAll", { productId });
+  invalidateNodeCache(productId);
+}
+async function getReadinessReport(id) {
+  const res = await proxy("readiness.get", { id });
+  return res.doc;
+}
+async function saveReadinessReport(id, data) {
+  return proxy("readiness.save", { id, data });
+}
+async function generateReadinessReportViaProxy(input) {
+  const { productId, ownerUid, computeMetricsFromGraph: computeMetrics, computeGrade } = input;
+  const [entities, edges, constraintNodes, bindings] = await Promise.all([
+    getAllEntities(productId),
+    getAllEdges(productId),
+    getAllNodes(productId),
+    getAllBindings(productId)
+  ]);
+  if (entities.length === 0 && constraintNodes.length === 0) {
+    throw new Error(`No graph data for product "${productId}". Run graph_ingest_requirements or constraints_ingest first.`);
+  }
+  const metrics = computeMetrics(entities, edges, constraintNodes, bindings);
+  const readinessPct = metrics.engineering_readiness_pct ?? 0;
+  const jobData = await getPremortem(productId);
+  const result = jobData?.result;
+  const productName = result?.project?.name || jobData?.payload?.project?.name || "Untitled Product";
+  const verdict = result?.decision?.recommendation;
+  const techStack = entities.filter((e) => e.type === "component").map((e) => e.name).slice(0, 15);
+  const reportId = productId;
+  const now = /* @__PURE__ */ new Date();
+  const existing = await getReadinessReport(reportId);
+  const report = {
+    productId,
+    productName,
+    ownerUid,
+    grade: computeGrade(readinessPct),
+    readinessPct: Math.round(readinessPct),
+    securityReadinessPct: Math.round(metrics.security_readiness_pct ?? 0),
+    reliabilityReadinessPct: Math.round(metrics.reliability_readiness_pct ?? 0),
+    scalabilityReadinessPct: Math.round(metrics.scalability_readiness_pct ?? 0),
+    nfrCoverage: metrics.nfr_coverage,
+    timeEstimate: {
+      unassisted_hours: metrics.time_estimate.unassisted_hours,
+      assisted_hours: metrics.time_estimate.assisted_hours,
+      speedup_factor: metrics.time_estimate.speedup_factor
+    },
+    complexityFactors: {
+      entity_count: metrics.complexity_factors.entity_count,
+      nfr_count: metrics.complexity_factors.nfr_count,
+      critical_nfr_count: metrics.complexity_factors.critical_nfr_count,
+      pii_data_types: metrics.complexity_factors.pii_data_types,
+      conflict_count: metrics.complexity_factors.conflict_count
+    },
+    rgrCompletedPhases: metrics.rgr_completed_phases ?? [],
+    complianceFrameworks: metrics.compliance_frameworks ?? [],
+    verdict,
+    techStack,
+    public: true,
+    createdAt: existing?.createdAt ? new Date(existing.createdAt) : now,
+    updatedAt: now
+  };
+  await saveReadinessReport(reportId, report);
+  return { report, reportId };
+}
+async function listTemplates(opts) {
+  const res = await proxy("template.list", opts || {});
+  return res.docs;
+}
+async function getTemplate(id) {
+  const res = await proxy("template.get", { id });
+  return res.doc;
+}
+async function createTemplate(data, id) {
+  return proxy("template.create", { data, id });
+}
+async function updateTemplate(id, data) {
+  return proxy("template.update", { id, data });
+}
+async function saveScanReport(data, collection, id) {
+  return proxy("scan.save", { data, collection, id });
+}
+async function getScanRateLimit() {
+  return proxy("scan.rateCheck", {});
+}
+async function updateScanRateLimit(data) {
+  return proxy("scan.rateUpdate", { data });
+}
+async function listPersonas(productId) {
+  const res = await proxy("persona.list", { productId });
+  return res.docs;
+}
+async function getPersona(personaId) {
+  const res = await proxy("persona.get", { id: personaId });
+  return res.doc;
+}
+
+export {
+  listPremortems,
+  getPremortem,
+  createPremortem,
+  updatePremortem,
+  getIdeaReport,
+  saveChat,
+  getChat,
+  updateChat,
+  createExplorationSession,
+  getExplorationSession,
+  updateExplorationSession,
+  listExplorationSessions,
+  getAllEntities,
+  upsertEntities,
+  addEntity,
+  getEntityById,
+  getEntitiesWithEmbeddings,
+  updateEntityEmbedding,
+  getAllEdges,
+  upsertEdges,
+  addEdges,
+  getAllBindings,
+  getBindingsForEntity,
+  upsertBindings,
+  deleteBinding,
+  getAllNodes,
+  getAllNodesLight,
+  getNodesByCategories,
+  getNodesBySource,
+  upsertNodes,
+  addNodes,
+  deleteAllNodes,
+  hasConstraints,
+  searchNodesByKeywords,
+  getNodesWithEmbeddings,
+  getNodesMissingEmbeddings,
+  updateNodeEmbeddings,
+  addTestCases,
+  getTestCasesForEntity,
+  getTestCasesForProduct,
+  getGraphMetadata,
+  updateGraphMetadata,
+  recordScoreSnapshot,
+  deleteGraphData,
+  getReadinessReport,
+  saveReadinessReport,
+  generateReadinessReportViaProxy,
+  listTemplates,
+  getTemplate,
+  createTemplate,
+  updateTemplate,
+  saveScanReport,
+  getScanRateLimit,
+  updateScanRateLimit,
+  listPersonas,
+  getPersona
+};