@clue-ai/cli 0.0.5 → 0.0.7

package/commands/claude-code/clue-init.md

@@ -11,10 +11,17 @@ Required fields:
 - `allowed_source_paths`
 - `excluded_source_paths`
 
-Required secrets:
+Required environment:
 
 - `CLUE_API_KEY`
-- `AI_PROVIDER_API_KEY`
+- `CLUE_AI_PROVIDER_API_KEY`
+- `CLUE_AI_PROVIDER`
+- `CLUE_AI_MODEL`
+
+Semantic snapshot generation runs inside the customer repository CI with the
+customer-configured AI provider key. Clue must receive only the final
+privacy-safe semantic snapshot, not raw source code, prompts, completions, or AI
+provider keys.
 
 Behavior:
 

package/commands/codex/clue-init.md

@@ -11,10 +11,17 @@ Required fields:
 - `allowed_source_paths`
 - `excluded_source_paths`
 
-Required secrets:
+Required environment:
 
 - `CLUE_API_KEY`
-- `AI_PROVIDER_API_KEY`
+- `CLUE_AI_PROVIDER_API_KEY`
+- `CLUE_AI_PROVIDER`
+- `CLUE_AI_MODEL`
+
+Semantic snapshot generation runs inside the customer repository CI with the
+customer-configured AI provider key. Clue must receive only the final
+privacy-safe semantic snapshot, not raw source code, prompts, completions, or AI
+provider keys.
 
 Behavior:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clue-ai/cli",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "type": "module",
   "bin": {
     "clue-ai": "bin/clue-cli.mjs"

package/src/ai-provider.mjs

@@ -0,0 +1,147 @@
+const SUPPORTED_AI_PROVIDERS = new Set(["openai", "anthropic"]);
+
+const normalizeProvider = (value) => {
+  const provider = String(value || "openai")
+    .trim()
+    .toLowerCase();
+  if (!SUPPORTED_AI_PROVIDERS.has(provider)) {
+    throw new Error(
+      `CLUE_AI_PROVIDER must be one of: ${Array.from(SUPPORTED_AI_PROVIDERS).join(", ")}`,
+    );
+  }
+  return provider;
+};
+
+const trimTrailingSlash = (value) => String(value).replace(/\/+$/, "");
+
+const providerBaseUrl = ({ provider, env = {}, request = {} }) => {
+  const explicit = env.CLUE_AI_PROVIDER_BASE_URL || null;
+  if (explicit) {
+    return trimTrailingSlash(explicit);
+  }
+  return provider === "anthropic"
+    ? "https://api.anthropic.com/v1"
+    : "https://api.openai.com/v1";
+};
+
+const providerModel = ({ env = {}, request = {} }) => {
+  const configuredModel =
+    env.CLUE_INIT_AI_MODEL || env.CLUE_AI_MODEL || request.ai_model;
+  const model = String(configuredModel || "").trim();
+  if (!model) {
+    throw new Error("CLUE_AI_MODEL is required");
+  }
+  return model;
+};
+
+export const resolveAiProviderConfig = ({ env = {}, request = {}, apiKey }) => {
+  const provider = normalizeProvider(
+    request.ai_provider || env.CLUE_AI_PROVIDER,
+  );
+  const resolvedApiKey = apiKey || env.CLUE_AI_PROVIDER_API_KEY;
+  if (!resolvedApiKey) {
+    throw new Error("CLUE_AI_PROVIDER_API_KEY is required");
+  }
+  return {
+    provider,
+    apiKey: resolvedApiKey,
+    baseUrl: providerBaseUrl({ provider, env, request }),
+    model: providerModel({ env, request }),
+  };
+};
+
+const parseOpenAiJson = async ({ response, emptyMessage }) => {
+  const body = await response.json();
+  const content = body?.choices?.[0]?.message?.content;
+  if (typeof content !== "string" || content.trim() === "") {
+    throw new Error(emptyMessage);
+  }
+  return JSON.parse(content);
+};
+
+const parseAnthropicJson = async ({ response, toolName, emptyMessage }) => {
+  const body = await response.json();
+  const toolUse = Array.isArray(body?.content)
+    ? body.content.find(
+        (entry) => entry?.type === "tool_use" && entry.name === toolName,
+      )
+    : null;
+  if (toolUse?.input && typeof toolUse.input === "object") {
+    return toolUse.input;
+  }
+  const text = Array.isArray(body?.content)
+    ? body.content
+        .filter(
+          (entry) => entry?.type === "text" && typeof entry.text === "string",
+        )
+        .map((entry) => entry.text)
+        .join("")
+        .trim()
+    : "";
+  if (!text) {
+    throw new Error(emptyMessage);
+  }
+  return JSON.parse(text);
+};
+
+export const callJsonAiProvider = async ({
+  config,
+  system,
+  user,
+  toolName = "return_json",
+  toolDescription = "Return schema-valid JSON for this Clue task.",
+  failureMessage = "AI provider failed",
+  emptyMessage = "AI provider returned empty content",
+}) => {
+  const response =
+    config.provider === "anthropic"
+      ? await fetch(`${config.baseUrl}/messages`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "x-api-key": config.apiKey,
+            "anthropic-version": "2023-06-01",
+          },
+          body: JSON.stringify({
+            model: config.model,
+            max_tokens: 4096,
+            temperature: 0,
+            system,
+            messages: [{ role: "user", content: user }],
+            tools: [
+              {
+                name: toolName,
+                description: toolDescription,
+                input_schema: {
+                  type: "object",
+                  additionalProperties: true,
+                },
+              },
+            ],
+            tool_choice: { type: "tool", name: toolName },
+          }),
+        })
+      : await fetch(`${config.baseUrl}/chat/completions`, {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            authorization: `Bearer ${config.apiKey}`,
+          },
+          body: JSON.stringify({
+            model: config.model,
+            temperature: 0,
+            messages: [
+              { role: "system", content: system },
+              { role: "user", content: user },
+            ],
+            response_format: { type: "json_object" },
+          }),
+        });
+
+  if (!response.ok) {
+    throw new Error(`${failureMessage}: ${response.status}`);
+  }
+  return config.provider === "anthropic"
+    ? parseAnthropicJson({ response, toolName, emptyMessage })
+    : parseOpenAiJson({ response, emptyMessage });
+};

package/src/command-spec.mjs

@@ -2,8 +2,9 @@ export const CLUE_INIT_COMMAND_NAME = "/clue-init";
 
 export const REQUIRED_SECRET_NAMES = [
   "CLUE_API_KEY",
-  "AI_PROVIDER_API_KEY",
+  "CLUE_AI_PROVIDER_API_KEY",
 ];
+export const REQUIRED_VARIABLE_NAMES = ["CLUE_AI_PROVIDER", "CLUE_AI_MODEL"];
 
 export const CLUE_INIT_COMMAND_FIELDS = [
   "project_key",
@@ -22,6 +23,7 @@ export const CLUE_INIT_COMMAND = {
   report_contract: "clueInitToolReportSchema",
   required_fields: CLUE_INIT_COMMAND_FIELDS,
   required_secret_names: REQUIRED_SECRET_NAMES,
+  required_variable_names: REQUIRED_VARIABLE_NAMES,
 };
 
 export const commandSpecs = [CLUE_INIT_COMMAND];
@@ -55,15 +57,14 @@ const deriveServiceKeyFromBackendRootPath = (backendRootPath) => {
     .replace(/[^a-z0-9_-]+/g, "-")
     .replace(/^-+|-+$/g, "");
   if (!normalized) {
-    throw new Error(`service_key cannot be derived from backend_root_path for ${CLUE_INIT_COMMAND_NAME}`);
+    throw new Error(
+      `service_key cannot be derived from backend_root_path for ${CLUE_INIT_COMMAND_NAME}`,
+    );
   }
   return normalized;
 };
 
-export const buildClueInitRequestFromCommandInput = ({
-  targetTool,
-  input,
-}) => {
+export const buildClueInitRequestFromCommandInput = ({ targetTool, input }) => {
   const backendRootPath = requireField(input, "backend_root_path");
   const serviceKey =
     typeof input?.service_key === "string" && input.service_key.trim()
@@ -85,7 +86,8 @@ export const buildClueInitRequestFromCommandInput = ({
       [],
       "excluded_source_paths",
     ),
-    ...(typeof input?.ci_workflow_path === "string" && input.ci_workflow_path.trim()
+    ...(typeof input?.ci_workflow_path === "string" &&
+    input.ci_workflow_path.trim()
       ? { ci_workflow_path: input.ci_workflow_path.trim() }
       : {}),
   };

package/src/contracts.mjs

@@ -2,7 +2,6 @@ import { createRequire } from "node:module";
 
 const require = createRequire(import.meta.url);
 const schemaPackage = require("./public-schema.cjs");
-
 const {
   clueInitToolRequestSchema,
   clueInitToolReportSchema,
@@ -48,7 +47,11 @@ const stringArray = (value, field, { min = 0 } = {}) => {
 };
 
 export const validateInitRequest = (input) => {
-  const parsed = parseWithSchema(clueInitToolRequestSchema, input, "init request");
+  const parsed = parseWithSchema(
+    clueInitToolRequestSchema,
+    input,
+    "init request",
+  );
   return {
     ...parsed,
     allowed_source_paths: [...new Set(parsed.allowed_source_paths)],
@@ -56,14 +59,20 @@ export const validateInitRequest = (input) => {
   };
 };
 
-export const buildInitReport = ({ request, lifecycleInsertions, warnings = [] }) =>
+export const buildInitReport = ({
+  request,
+  lifecycleInsertions,
+  requiredVariables = [],
+  warnings = [],
+}) =>
   parseWithSchema(
     clueInitToolReportSchema,
     {
       target_tool: request.target_tool,
       ci_workflow_path: request.ci_workflow_path,
       ci_workflow_added: true,
-      required_secrets: ["CLUE_API_KEY", "AI_PROVIDER_API_KEY"],
+      required_secrets: ["CLUE_API_KEY", "CLUE_AI_PROVIDER_API_KEY"],
+      required_variables: requiredVariables,
       lifecycle_insertions: lifecycleInsertions,
       semantic_generation_timing: "after_merge_ci",
       semantic_preview_generated: false,
@@ -83,7 +92,10 @@ export const validateSemanticCiRequest = (input) => ({
   service_key: nonEmpty(input.service_key, "service_key"),
   repository: {
     provider: nonEmpty(input.repository?.provider, "repository.provider"),
-    repository_id: nonEmpty(input.repository?.repository_id, "repository.repository_id"),
+    repository_id: nonEmpty(
+      input.repository?.repository_id,
+      "repository.repository_id",
+    ),
     ...(optionalNonEmpty(input.repository?.owner)
       ? { owner: optionalNonEmpty(input.repository.owner) }
       : {}),
@@ -93,11 +105,15 @@ export const validateSemanticCiRequest = (input) => ({
     ...(optionalNonEmpty(input.repository?.default_branch)
       ? { default_branch: optionalNonEmpty(input.repository.default_branch) }
       : {}),
-    merge_commit: nonEmpty(input.repository?.merge_commit, "repository.merge_commit"),
+    merge_commit: nonEmpty(
+      input.repository?.merge_commit,
+      "repository.merge_commit",
+    ),
     ...(optionalNonEmpty(input.repository?.merged_at)
       ? { merged_at: optionalNonEmpty(input.repository.merged_at) }
       : {}),
-    ...(input.repository?.pull_request_number === undefined || input.repository?.pull_request_number === null
+    ...(input.repository?.pull_request_number === undefined ||
+    input.repository?.pull_request_number === null
       ? {}
       : { pull_request_number: input.repository.pull_request_number }),
     ...(optionalNonEmpty(input.repository?.workflow_run_id)
@@ -105,25 +121,44 @@ export const validateSemanticCiRequest = (input) => ({
       : {}),
   },
   service: {
-    service_key: nonEmpty(input.service?.service_key ?? input.service_key, "service.service_key"),
+    service_key: nonEmpty(
+      input.service?.service_key ?? input.service_key,
+      "service.service_key",
+    ),
     root_path: input.service?.root_path ?? null,
     framework: input.service?.framework ?? "fastapi",
     language: input.service?.language ?? "python",
   },
-	  allowed_source_paths: stringArray(input.allowed_source_paths, "allowed_source_paths", { min: 1 }),
-	  excluded_source_paths: stringArray(input.excluded_source_paths ?? [], "excluded_source_paths"),
-	  clue_api_base_url: nonEmpty(input.clue_api_base_url, "clue_api_base_url"),
-	  ai_provider_base_url: optionalNonEmpty(input.ai_provider_base_url) ?? "https://api.openai.com/v1",
-	  ai_model: optionalNonEmpty(input.ai_model) ?? "gpt-5.4-mini",
-	});
+  allowed_source_paths: stringArray(
+    input.allowed_source_paths,
+    "allowed_source_paths",
+    { min: 1 },
+  ),
+  excluded_source_paths: stringArray(
+    input.excluded_source_paths ?? [],
+    "excluded_source_paths",
+  ),
+  clue_api_base_url: nonEmpty(input.clue_api_base_url, "clue_api_base_url"),
+  ai_provider_base_url: null,
+  ai_provider: optionalNonEmpty(input.ai_provider),
+  ai_model: optionalNonEmpty(input.ai_model),
+});
 
 export const buildOperationSourceKey = (method, pathTemplate) =>
   `route.${method.toUpperCase()}.${pathTemplate}`;
 
 export const validateSemanticSnapshotRequest = (input) => {
-  return parseWithSchema(semanticSnapshotRequestSchema, input, "semantic snapshot");
+  return parseWithSchema(
+    semanticSnapshotRequestSchema,
+    input,
+    "semantic snapshot",
+  );
 };
 
 export const validateSemanticSnapshotResponse = (input) => {
-  return parseWithSchema(semanticSnapshotResponseSchema, input, "semantic snapshot response");
+  return parseWithSchema(
+    semanticSnapshotResponseSchema,
+    input,
+    "semantic snapshot response",
+  );
 };