agentweaver 0.1.14 → 0.1.16

package/dist/doctor/checks/env-diagnostics.js

@@ -1,8 +1,10 @@
 import { existsSync, readFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { DoctorStatus } from "../types.js";
+import { DoctorImpact, DoctorStatus } from "../types.js";
 import { CATEGORY } from "./category.js";
+import { detectJiraDeployment } from "../../jira.js";
+import { AGENTWEAVER_REVIEW_BLOCKING_SEVERITIES_ENV, parseReviewSeverityCsv, } from "../../review-severity.js";
 const MONITORED_KEYS = [
     "JIRA_API_KEY",
     "JIRA_USERNAME",
@@ -10,6 +12,7 @@ const MONITORED_KEYS = [
     "JIRA_BASE_URL",
     "GITLAB_TOKEN",
     "AGENTWEAVER_HOME",
+    "AGENTWEAVER_REVIEW_BLOCKING_SEVERITIES",
     "CODEX_BIN",
     "CODEX_MODEL",
     "OPENCODE_BIN",
@@ -17,19 +20,17 @@ const MONITORED_KEYS = [
 ];
 const SECRET_KEYS = new Set(["JIRA_API_KEY", "GITLAB_TOKEN"]);
 const JIRA_AUTH_MODE_ALLOWED_VALUES = ["auto", "basic", "bearer"];
-function maskSecret(value) {
-    if (value.length <= 6) {
-        if (value.length <= 3) {
-            return "***";
-        }
-        const start = value.slice(0, Math.ceil(value.length / 2));
-        const end = value.slice(Math.ceil(value.length / 2));
-        return `${start}***${end}`;
-    }
-    const start = value.slice(0, 3);
-    const end = value.slice(-3);
-    return `${start}***${end}`;
-}
+const KEY_NOTES = {
+    JIRA_API_KEY: "Required for Jira-backed flows.",
+    JIRA_USERNAME: "Required only for Jira Cloud basic auth.",
+    GITLAB_TOKEN: "Required for GitLab-backed flows.",
+    AGENTWEAVER_HOME: "Optional override for the AgentWeaver package home.",
+    AGENTWEAVER_REVIEW_BLOCKING_SEVERITIES: "Optional default list of merge-blocking severities for review and review-fix.",
+    CODEX_BIN: "Optional override for the codex executable path.",
+    CODEX_MODEL: "Optional fallback model override for Codex-backed executors.",
+    OPENCODE_BIN: "Optional override for the opencode executable path.",
+    OPENCODE_MODEL: "Optional fallback model override for OpenCode-backed executors.",
+};
 function globalConfigDir() {
     return path.join(os.homedir(), ".agentweaver");
 }
@@ -69,101 +70,222 @@ function getProjectEnvPath() {
 function getGlobalEnvPath() {
     return path.join(globalConfigDir(), ".env");
 }
-function determineSource(key, shellSnapshot, currentValue) {
+function determineSource(key, shellSnapshot, projectEnv, globalEnv, currentValue) {
     if (currentValue === null) {
         return "missing";
     }
-    const isInShellSnapshot = shellSnapshot.hasOwnProperty(key);
-    if (isInShellSnapshot) {
+    if (Object.prototype.hasOwnProperty.call(shellSnapshot, key)) {
         return "shell";
     }
-    const globalEnv = parseEnvFileRaw(getGlobalEnvPath());
-    if (globalEnv.hasOwnProperty(key)) {
-        return "global";
-    }
-    const projectEnv = parseEnvFileRaw(getProjectEnvPath());
-    if (projectEnv.hasOwnProperty(key)) {
+    if (Object.prototype.hasOwnProperty.call(projectEnv, key)) {
         return "project-local";
     }
+    if (Object.prototype.hasOwnProperty.call(globalEnv, key)) {
+        return "global";
+    }
     return "shell";
 }
-function getDefaultValue(key) {
-    switch (key) {
-        case "AGENTWEAVER_HOME":
-            return path.join(os.homedir(), ".agentweaver");
-        default:
-            return null;
+function defaultNote(key) {
+    if (key === "JIRA_AUTH_MODE") {
+        return "Defaults to auto.";
+    }
+    if (key === AGENTWEAVER_REVIEW_BLOCKING_SEVERITIES_ENV) {
+        return "Defaults to blocker,critical,high.";
     }
+    return null;
 }
 function validateJiraAuthMode(value) {
     if (value === null) {
         return true;
     }
-    return JIRA_AUTH_MODE_ALLOWED_VALUES.includes(value);
+    return JIRA_AUTH_MODE_ALLOWED_VALUES.includes(value.trim().toLowerCase());
+}
+function validateReviewBlockingSeverities(value) {
+    if (value === null) {
+        return true;
+    }
+    try {
+        parseReviewSeverityCsv(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function keyNote(key) {
+    return KEY_NOTES[key];
+}
+function formatKeyLine(info) {
+    const source = info.state === "unset" ? "unset" : info.source === "default" ? "default" : info.source;
+    const secretLabel = info.isSecret ? ", secret" : "";
+    const noteLabel = info.note ? `, ${info.note}` : "";
+    return `- ${info.key} (${source}${secretLabel}${noteLabel})`;
+}
+function buildDetails(configured, defaulted, unset, invalid, warnings) {
+    const lines = [];
+    if (warnings.length > 0) {
+        lines.push("warnings:");
+        for (const warning of warnings) {
+            lines.push(`- ${warning}`);
+        }
+    }
+    if (configured.length > 0) {
+        if (lines.length > 0) {
+            lines.push("");
+        }
+        lines.push("configured:");
+        for (const info of configured) {
+            lines.push(formatKeyLine(info));
+        }
+    }
+    if (defaulted.length > 0) {
+        if (lines.length > 0) {
+            lines.push("");
+        }
+        lines.push("defaulted:");
+        for (const info of defaulted) {
+            lines.push(formatKeyLine(info));
+        }
+    }
+    if (unset.length > 0) {
+        if (lines.length > 0) {
+            lines.push("");
+        }
+        lines.push("unset:");
+        for (const info of unset) {
+            lines.push(formatKeyLine(info));
+        }
+    }
+    if (invalid.length > 0) {
+        if (lines.length > 0) {
+            lines.push("");
+        }
+        lines.push("invalid:");
+        for (const info of invalid) {
+            lines.push(formatKeyLine(info));
+        }
+    }
+    return lines.join("\n");
 }
 function checkEnvDiagnostics() {
     const shellSnapshot = {};
     for (const key of Object.keys(process.env)) {
-        shellSnapshot[key] = process.env[key];
+        const value = process.env[key];
+        if (value !== undefined) {
+            shellSnapshot[key] = value;
+        }
     }
     const projectEnv = parseEnvFileRaw(getProjectEnvPath());
     const globalEnv = parseEnvFileRaw(getGlobalEnvPath());
     const keyInfos = [];
-    let hasWarnings = false;
+    const warnings = [];
+    const jiraApiKey = process.env.JIRA_API_KEY?.trim() || null;
+    const jiraUsername = process.env.JIRA_USERNAME?.trim() || null;
+    const jiraAuthModeRaw = process.env.JIRA_AUTH_MODE?.trim() || null;
+    const jiraBaseUrl = process.env.JIRA_BASE_URL?.trim() || null;
+    const reviewBlockingSeveritiesRaw = process.env[AGENTWEAVER_REVIEW_BLOCKING_SEVERITIES_ENV]?.trim() || null;
     for (const key of MONITORED_KEYS) {
-        const currentValue = process.env[key] ?? null;
-        const source = determineSource(key, shellSnapshot, currentValue);
+        const currentValue = process.env[key]?.trim() || null;
         const isSecret = SECRET_KEYS.has(key);
-        let maskedValue = null;
-        if (currentValue !== null && isSecret) {
-            maskedValue = maskSecret(currentValue);
+        const source = determineSource(key, shellSnapshot, projectEnv, globalEnv, currentValue);
+        const defaultHint = currentValue === null ? defaultNote(key) : null;
+        let state = "configured";
+        if (currentValue === null && defaultHint) {
+            state = "defaulted";
         }
-        else if (currentValue !== null) {
-            maskedValue = currentValue;
+        else if (currentValue === null) {
+            state = "unset";
         }
-        const keyInfo = {
+        if (key === "JIRA_AUTH_MODE" && currentValue !== null && !validateJiraAuthMode(currentValue)) {
+            state = "invalid";
+        }
+        if (key === AGENTWEAVER_REVIEW_BLOCKING_SEVERITIES_ENV && currentValue !== null && !validateReviewBlockingSeverities(currentValue)) {
+            state = "invalid";
+        }
+        const note = state === "defaulted" ? defaultHint ?? undefined : keyNote(key);
+        keyInfos.push({
             key,
-            source,
-            value: currentValue,
-            maskedValue,
+            source: state === "defaulted" ? "default" : source,
+            state,
             isSecret,
-        };
-        keyInfos.push(keyInfo);
-        if (source === "missing") {
-            hasWarnings = true;
-        }
-        if (key === "JIRA_AUTH_MODE" && currentValue !== null) {
-            if (!validateJiraAuthMode(currentValue)) {
-                hasWarnings = true;
-            }
-        }
-    }
-    const status = hasWarnings ? DoctorStatus.Warn : DoctorStatus.Ok;
-    const keyCount = keyInfos.length;
-    const missingCount = keyInfos.filter(k => k.source === "missing").length;
-    const secretCount = keyInfos.filter(k => k.isSecret).length;
-    const summaryParts = [];
-    summaryParts.push(`${keyCount} keys checked`);
-    if (missingCount > 0) {
-        summaryParts.push(`${missingCount} missing`);
-    }
-    if (secretCount > 0) {
-        summaryParts.push(`${secretCount} secrets`);
-    }
-    const result = {
+            ...(note ? { note } : {}),
+        });
+    }
+    const jiraHasAnyConfig = !!(jiraApiKey || jiraBaseUrl || jiraUsername || jiraAuthModeRaw);
+    const jiraHasCorePair = !!(jiraApiKey && jiraBaseUrl);
+    if ((jiraApiKey && !jiraBaseUrl) || (!jiraApiKey && jiraBaseUrl)) {
+        warnings.push("Jira configuration is partial: set both JIRA_API_KEY and JIRA_BASE_URL for Jira-backed flows.");
+    }
+    if (jiraAuthModeRaw !== null && !validateJiraAuthMode(jiraAuthModeRaw)) {
+        warnings.push("JIRA_AUTH_MODE must be one of: auto, basic, bearer.");
+    }
+    if (reviewBlockingSeveritiesRaw !== null && !validateReviewBlockingSeverities(reviewBlockingSeveritiesRaw)) {
+        warnings.push("AGENTWEAVER_REVIEW_BLOCKING_SEVERITIES must be a comma-separated list of: blocker, critical, high, medium, low, info.");
+    }
+    if (jiraHasCorePair && jiraBaseUrl) {
+        const authMode = jiraAuthModeRaw?.toLowerCase() || "auto";
+        const isCloud = detectJiraDeployment(jiraBaseUrl) === "cloud";
+        const usesBasicAuth = authMode === "basic" || (authMode === "auto" && isCloud);
+        if (usesBasicAuth && !jiraUsername) {
+            warnings.push("JIRA_USERNAME is required for Jira Cloud basic auth with the current Jira URL and auth mode.");
+        }
+    }
+    else if (jiraHasAnyConfig && jiraUsername && !jiraApiKey && !jiraBaseUrl) {
+        warnings.push("JIRA_USERNAME is set without the Jira API key/base URL pair.");
+    }
+    const configured = keyInfos.filter((info) => info.state === "configured");
+    const defaulted = keyInfos.filter((info) => info.state === "defaulted");
+    const unset = keyInfos.filter((info) => info.state === "unset");
+    const invalid = keyInfos.filter((info) => info.state === "invalid");
+    const status = warnings.length > 0 ? DoctorStatus.Warn : DoctorStatus.Ok;
+    const summary = {
+        checked: keyInfos.length,
+        configured: configured.length,
+        defaulted: defaulted.length,
+        unset: unset.length,
+        invalid: invalid.length,
+        secrets: keyInfos.filter((info) => info.isSecret).length,
+    };
+    const messageParts = [
+        `${summary.checked} keys checked`,
+        `${summary.configured} configured`,
+    ];
+    if (summary.defaulted > 0) {
+        messageParts.push(`${summary.defaulted} defaulted`);
+    }
+    if (summary.unset > 0) {
+        messageParts.push(`${summary.unset} unset`);
+    }
+    if (summary.invalid > 0) {
+        messageParts.push(`${summary.invalid} invalid`);
+    }
+    const details = buildDetails(configured, defaulted, unset, invalid, warnings);
+    const data = {
+        kind: "env-config",
+        summary,
+        warnings,
+        keys: keyInfos,
+    };
+    return {
         id: "env-diagnostics-01",
+        impact: DoctorImpact.Advisory,
         status,
         title: "env-config",
-        message: summaryParts.join(", "),
-        ...(missingCount > 0 ? { hint: `${missingCount} configuration keys are missing` } : {}),
-        details: JSON.stringify(keyInfos),
+        message: messageParts.join(", "),
+        ...(warnings.length > 0
+            ? { hint: `${warnings.length} configuration issue${warnings.length === 1 ? "" : "s"} detected` }
+            : unset.length > 0
+                ? { hint: "Unset keys are optional unless you use the related integrations or overrides" }
+                : {}),
+        details,
+        data,
     };
-    return result;
 }
 export const envDiagnosticsCheck = {
     id: "env-diagnostics-01",
     category: CATEGORY.ENV_DIAGNOSTICS,
     title: "env-config",
+    impact: DoctorImpact.Advisory,
     dependencies: [],
     execute: async () => {
         return checkEnvDiagnostics();