@clue-ai/cli 0.0.5 → 0.0.6

package/src/semantic-ci.mjs

@@ -1,4 +1,5 @@
 import { createHash, createHmac } from "node:crypto";
+import { callJsonAiProvider, resolveAiProviderConfig } from "./ai-provider.mjs";
 import {
   validateSemanticCiRequest,
   validateSemanticSnapshotRequest,
@@ -244,9 +245,11 @@ const normalizeReuseDecision = ({ parsed, operationSourceKey }) => {
       reason: "AI reuse decision omitted this changed route.",
     };
   }
-  const normalizedDecision = ["reuse_previous", "regenerate", "needs_review"].includes(
-    decision.decision,
-  )
+  const normalizedDecision = [
+    "reuse_previous",
+    "regenerate",
+    "needs_review",
+  ].includes(decision.decision)
     ? decision.decision
     : "needs_review";
   return {
@@ -263,109 +266,67 @@ const normalizeReuseDecision = ({ parsed, operationSourceKey }) => {
 
 const callAiReuseDecisionProvider = async ({
   request,
+  env,
   apiKey,
   route,
   previousRoute,
   currentHash,
 }) => {
-  const response = await fetch(
-    `${request.ai_provider_base_url.replace(/\/+$/, "")}/chat/completions`,
-    {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        authorization: `Bearer ${apiKey}`,
-      },
-      body: JSON.stringify({
-        model: request.ai_model,
-        messages: [
-          {
-            role: "system",
-            content:
-              "You judge whether previous route semantics can be reused from privacy-safe evidence.",
-          },
-          {
-            role: "user",
-            content: buildAiReuseDecisionPrompt({
-              route,
-              previousRoute,
-              currentHash,
-            }),
-          },
-        ],
-        response_format: { type: "json_object" },
-      }),
-    },
-  );
-  if (!response.ok) {
-    return {
-      decision: "needs_review",
-      confidence: 0,
-      reason: `AI reuse decision failed: provider_${response.status}.`,
-    };
-  }
-  const body = await response.json();
-  const content = body?.choices?.[0]?.message?.content;
-  if (typeof content !== "string" || content.trim() === "") {
-    return {
-      decision: "needs_review",
-      confidence: 0,
-      reason: "AI reuse decision returned empty content.",
-    };
-  }
   try {
+    const parsed = await callJsonAiProvider({
+      config: resolveAiProviderConfig({ env, request, apiKey }),
+      system:
+        "You judge whether previous route semantics can be reused from privacy-safe evidence.",
+      user: buildAiReuseDecisionPrompt({
+        route,
+        previousRoute,
+        currentHash,
+      }),
+      toolName: "return_reuse_decision",
+      toolDescription:
+        "Return whether the previous route semantics can be reused.",
+      failureMessage: "AI reuse decision failed",
+      emptyMessage: "AI reuse decision returned empty content.",
+    });
     return normalizeReuseDecision({
-      parsed: JSON.parse(content),
+      parsed,
       operationSourceKey: route.operation_source_key,
     });
-  } catch {
+  } catch (error) {
+    const providerStatusMatch =
+      error instanceof Error
+        ? /AI reuse decision failed: (?<status>\d+)/.exec(error.message)
+        : null;
     return {
       decision: "needs_review",
       confidence: 0,
-      reason: "AI reuse decision returned malformed JSON.",
+      reason: providerStatusMatch?.groups?.status
+        ? `AI reuse decision failed: provider_${providerStatusMatch.groups.status}.`
+        : "AI reuse decision returned malformed JSON.",
     };
   }
 };
 
 const requireAiProviderApiKey = (env) => {
-  const apiKey = env.AI_PROVIDER_API_KEY;
+  const apiKey = env.CLUE_AI_PROVIDER_API_KEY;
   if (!apiKey) {
-    throw new Error("AI_PROVIDER_API_KEY is required for semantic generation");
+    throw new Error(
+      "CLUE_AI_PROVIDER_API_KEY is required for semantic generation",
+    );
   }
   return apiKey;
 };
 
-const callAiProvider = async ({ request, apiKey, routes }) => {
-  const response = await fetch(
-    `${request.ai_provider_base_url.replace(/\/+$/, "")}/chat/completions`,
-    {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        authorization: `Bearer ${apiKey}`,
-      },
-      body: JSON.stringify({
-        model: request.ai_model,
-        messages: [
-          {
-            role: "system",
-            content: "You generate privacy-safe route semantics JSON.",
-          },
-          { role: "user", content: buildAiPrompt(routes) },
-        ],
-        response_format: { type: "json_object" },
-      }),
-    },
-  );
-  if (!response.ok) {
-    throw new Error(`AI provider failed: ${response.status}`);
-  }
-  const body = await response.json();
-  const content = body?.choices?.[0]?.message?.content;
-  if (typeof content !== "string" || content.trim() === "") {
-    throw new Error("AI provider returned empty semantic generation content");
-  }
-  const parsed = JSON.parse(content);
+const callAiProvider = async ({ request, env, apiKey, routes }) => {
+  const parsed = await callJsonAiProvider({
+    config: resolveAiProviderConfig({ env, request, apiKey }),
+    system: "You generate privacy-safe route semantics JSON.",
+    user: buildAiPrompt(routes),
+    toolName: "return_route_semantics",
+    toolDescription: "Return privacy-safe route semantics JSON.",
+    failureMessage: "AI provider failed",
+    emptyMessage: "AI provider returned empty semantic generation content",
+  });
   return new Map(
     (parsed.routes ?? []).map((route) => [route.operation_source_key, route]),
   );
@@ -413,12 +374,13 @@ const assertSnapshotRouteCoverage = ({ routes, snapshotRoutes }) => {
   }
 };
 
-const generateAiRoutesPerRoute = async ({ request, apiKey, routes }) => {
+const generateAiRoutesPerRoute = async ({ request, env, apiKey, routes }) => {
   const aiRoutes = new Map();
   for (const route of routes) {
     try {
       const routeAiRoutes = await callAiProvider({
         request,
+        env,
         apiKey,
         routes: [route],
       });
@@ -476,6 +438,7 @@ const buildAiSelectionPrompt = (selectionCandidates) =>
 
 const callAiSelectionProvider = async ({
   request,
+  env,
   apiKey,
   selectionCandidates,
   routeBySelectionKey,
@@ -484,40 +447,16 @@ const callAiSelectionProvider = async ({
     return new Map();
   }
   assertNoRawCodeStructure(selectionCandidates, "semantic_selection_prompt");
-  const response = await fetch(
-    `${request.ai_provider_base_url.replace(/\/+$/, "")}/chat/completions`,
-    {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        authorization: `Bearer ${apiKey}`,
-      },
-      body: JSON.stringify({
-        model: request.ai_model,
-        messages: [
-          {
-            role: "system",
-            content:
-              "You select adopted semantic values from privacy-safe candidates.",
-          },
-          {
-            role: "user",
-            content: buildAiSelectionPrompt(selectionCandidates),
-          },
-        ],
-        response_format: { type: "json_object" },
-      }),
-    },
-  );
-  if (!response.ok) {
-    throw new Error(`AI selector failed: ${response.status}`);
-  }
-  const body = await response.json();
-  const content = body?.choices?.[0]?.message?.content;
-  if (typeof content !== "string" || content.trim() === "") {
-    throw new Error("AI selector returned empty semantic selection content");
-  }
-  const parsed = JSON.parse(content);
+  const parsed = await callJsonAiProvider({
+    config: resolveAiProviderConfig({ env, request, apiKey }),
+    system: "You select adopted semantic values from privacy-safe candidates.",
+    user: buildAiSelectionPrompt(selectionCandidates),
+    toolName: "return_semantic_selection",
+    toolDescription:
+      "Return selected semantic values from privacy-safe candidates.",
+    failureMessage: "AI selector failed",
+    emptyMessage: "AI selector returned empty semantic selection content",
+  });
   return normalizeAiSelectionResponse({
     parsed,
     routeBySelectionKey,
@@ -1710,31 +1649,28 @@ const buildSnapshot = ({
         ? `changed_route_needs_review: ${plan.semantic_change_reason}`
         : (aiRoute?.confidence_reason ??
           "AI semantics were unavailable for this route.");
-    const baseRoute = !aiRoute?.semantics || plan.origin === "changed_route_needs_review"
-      ? fallbackSemantics(
-          routeWithVersion,
-          unavailableReason,
-          hashScope,
-        )
-      : {
-          operation_source_key: route.operation_source_key,
-          semantic_snapshot_version: semanticSnapshotVersion,
-          method: route.method,
-          path_template: route.path_template,
-          semantics: sanitizeSemantics(aiRoute.semantics, route),
-          layer_evidence: sanitizeLayerEvidence(
-            aiRoute.layer_evidence,
-            route,
-            hashScope,
-          ),
-          confidence_reason: sanitizeText(
-            String(
-              aiRoute.confidence_reason ||
-                "Generated by AI from privacy-safe route evidence.",
+    const baseRoute =
+      !aiRoute?.semantics || plan.origin === "changed_route_needs_review"
+        ? fallbackSemantics(routeWithVersion, unavailableReason, hashScope)
+        : {
+            operation_source_key: route.operation_source_key,
+            semantic_snapshot_version: semanticSnapshotVersion,
+            method: route.method,
+            path_template: route.path_template,
+            semantics: sanitizeSemantics(aiRoute.semantics, route),
+            layer_evidence: sanitizeLayerEvidence(
+              aiRoute.layer_evidence,
+              route,
+              hashScope,
             ),
-            route,
-          ),
-        };
+            confidence_reason: sanitizeText(
+              String(
+                aiRoute.confidence_reason ||
+                  "Generated by AI from privacy-safe route evidence.",
+              ),
+              route,
+            ),
+          };
     const assignmentCollections = buildOperationAssignmentCollections({
       route,
       aiRoute,
@@ -1794,7 +1730,11 @@ const buildSnapshot = ({
   );
 
   const uniqueSourceEvidenceRefs = [];
-  addUniqueBy(uniqueSourceEvidenceRefs, sourceEvidenceRefs, (entry) => entry.id);
+  addUniqueBy(
+    uniqueSourceEvidenceRefs,
+    sourceEvidenceRefs,
+    (entry) => entry.id,
+  );
 
   const snapshot = validateSemanticSnapshotRequest({
     project_key: request.project_key,
@@ -1816,10 +1756,9 @@ const buildSnapshot = ({
       ).length,
       failed_routes: failedRouteCount,
       routes_reused: snapshotRoutes.filter((route) =>
-        [
-          "unchanged_route_reused",
-          "changed_route_semantic_reused",
-        ].includes(route.semantic_origin),
+        ["unchanged_route_reused", "changed_route_semantic_reused"].includes(
+          route.semantic_origin,
+        ),
       ).length,
       routes_ai_generated: snapshotRoutes.filter((route) =>
         [
@@ -2039,6 +1978,7 @@ const buildRouteEvidencePromptEntry = ({ route, hashScope }) => ({
 
 const classifyRoutesForSnapshot = async ({
   request,
+  env,
   routes,
   previousSnapshot,
   aiProviderApiKey,
@@ -2076,6 +2016,7 @@ const classifyRoutesForSnapshot = async ({
 
     const decision = await callAiReuseDecisionProvider({
       request,
+      env,
       apiKey: aiProviderApiKey,
       route: buildRouteEvidencePromptEntry({ route, hashScope }),
       previousRoute,
@@ -2158,7 +2099,13 @@ const rebasePreviousRoute = ({
   };
 };
 
-const fieldPathMatchesKeys = ({ fieldPath, routeKeys, profileIds, mappingIds, catalogKeys }) => {
+const fieldPathMatchesKeys = ({
+  fieldPath,
+  routeKeys,
+  profileIds,
+  mappingIds,
+  catalogKeys,
+}) => {
   for (const routeKey of routeKeys) {
     if (fieldPath.startsWith(`routes[${routeKey}]`)) {
       return true;
@@ -2197,7 +2144,9 @@ const reusablePreviousContext = ({ previousSnapshot, reusedRouteKeys }) => {
     ...safeArray(previousSnapshot?.routes)
       .filter((route) => routeKeys.has(route.operation_source_key))
       .flatMap((route) =>
-        safeArray(route.operation_effects).map((effect) => effect.target_object_key),
+        safeArray(route.operation_effects).map(
+          (effect) => effect.target_object_key,
+        ),
       ),
   ]);
   const catalogs = safeArray(previousSnapshot?.target_object_catalog).filter(
@@ -2274,9 +2223,9 @@ const reusablePreviousContext = ({ previousSnapshot, reusedRouteKeys }) => {
       sourceEvidenceIds.add(ref);
     }
   }
-  const sourceEvidenceRefs = safeArray(previousSnapshot?.source_evidence_refs).filter(
-    (entry) => sourceEvidenceIds.has(entry.id),
-  );
+  const sourceEvidenceRefs = safeArray(
+    previousSnapshot?.source_evidence_refs,
+  ).filter((entry) => sourceEvidenceIds.has(entry.id));
   return {
     profiles,
     mappings,
@@ -2396,7 +2345,9 @@ const semanticSnapshotUrl = (baseUrl) => {
 };
 
 const semanticSnapshotLatestUrl = (request) => {
-  const url = new URL(`${semanticSnapshotUrl(request.clue_api_base_url)}/latest`);
+  const url = new URL(
+    `${semanticSnapshotUrl(request.clue_api_base_url)}/latest`,
+  );
   url.searchParams.set("project_key", request.project_key);
   url.searchParams.set("environment", request.environment);
   url.searchParams.set("repository_id", request.repository.repository_id);
@@ -2501,22 +2452,29 @@ export const runSemanticCi = async ({
   const previousRoutes = previousRouteMap(previousSnapshot);
   const routeNeedsAi = routes.some((route) => {
     const previousRoute = previousRoutes.get(route.operation_source_key);
-    return !previousRoute || previousRoute.route_input_hash !== routeInputHash(route);
+    return (
+      !previousRoute || previousRoute.route_input_hash !== routeInputHash(route)
+    );
   });
   const aiProviderApiKey = routeNeedsAi ? requireAiProviderApiKey(env) : null;
-  const { plans: routePlans, routesRequiringGeneration, deletedRouteCount } =
-    await classifyRoutesForSnapshot({
-      request,
-      routes,
-      previousSnapshot,
-      aiProviderApiKey,
-      hashScope,
-    });
+  const {
+    plans: routePlans,
+    routesRequiringGeneration,
+    deletedRouteCount,
+  } = await classifyRoutesForSnapshot({
+    request,
+    env,
+    routes,
+    previousSnapshot,
+    aiProviderApiKey,
+    hashScope,
+  });
   const promptRoutes = routesRequiringGeneration.map((route) =>
     buildRouteEvidencePromptEntry({ route, hashScope }),
   );
   const aiRoutes = await generateAiRoutesPerRoute({
     request,
+    env,
     apiKey: aiProviderApiKey,
     routes: promptRoutes,
   });
@@ -2530,6 +2488,7 @@ export const runSemanticCi = async ({
       ? new Map()
       : await callAiSelectionProvider({
           request,
+          env,
           apiKey: aiProviderApiKey,
           selectionCandidates,
           routeBySelectionKey,