prismalens 0.2.0 → 0.4.0

package/dist/chunk-SSEIMBQ2.js

@@ -0,0 +1,204 @@
+import {
+  pickServiceLabel
+} from "./chunk-QDK5PAI3.js";
+
+// src/cli/grouping.ts
+import { createHash, randomUUID } from "node:crypto";
+function deriveGroupKey(alert, payload) {
+  if (typeof payload.groupKey === "string" && payload.groupKey) {
+    return payload.groupKey;
+  }
+  if (payload.groupLabels && typeof payload.groupLabels === "object") {
+    const labels = payload.groupLabels;
+    const keys = Object.keys(labels);
+    if (keys.length > 0) {
+      const sorted = keys.sort().map((k) => `${k}=${labels[k]}`).join(",");
+      return createHash("sha256").update(sorted).digest("hex");
+    }
+  }
+  const serviceLabel = pickServiceLabel(alert);
+  const alertname = alert.labels?.alertname || "";
+  if (serviceLabel) {
+    return `${alertname}\0${serviceLabel}`;
+  }
+  const alertLabels = alert.labels;
+  if (alertLabels && Object.keys(alertLabels).length > 0) {
+    const sorted = Object.keys(alertLabels).sort().map((k) => `${k}=${alertLabels[k]}`).join(",");
+    return createHash("sha256").update(sorted).digest("hex");
+  }
+  return "default";
+}
+function deriveDedupeKey(alert) {
+  if (typeof alert.fingerprint === "string" && alert.fingerprint) {
+    return alert.fingerprint;
+  }
+  const alertLabels = alert.labels;
+  const alertname = alertLabels?.alertname || "";
+  const sorted = alertLabels ? Object.keys(alertLabels).sort().map((k) => `${k}=${alertLabels[k]}`).join(",") : "";
+  const hash = createHash("sha256").update(sorted).digest("hex");
+  const startsAt = alert.startsAt || "";
+  return `${alertname}${hash}${startsAt}`;
+}
+function createGroupingLayer(options) {
+  let shuttingDown = false;
+  const windows = /* @__PURE__ */ new Map();
+  const running = /* @__PURE__ */ new Map();
+  const activeAlerts = /* @__PURE__ */ new Map();
+  return {
+    isShuttingDown() {
+      return shuttingDown;
+    },
+    newGroupCount(firing, payload) {
+      const keys = /* @__PURE__ */ new Set();
+      for (const alert of firing) {
+        const key = deriveGroupKey(alert, payload);
+        if (!windows.has(key) && !running.has(key)) {
+          keys.add(key);
+        }
+      }
+      return keys.size;
+    },
+    pendingGroups() {
+      return windows.size + running.size;
+    },
+    admit(firing, payload) {
+      if (shuttingDown) {
+        options.log("Dropped alert: grouping layer is shutting down");
+        return;
+      }
+      for (const alert of firing) {
+        const groupKey = deriveGroupKey(alert, payload);
+        const dedupeKey = deriveDedupeKey(alert);
+        if (activeAlerts.has(dedupeKey)) {
+          const active = activeAlerts.get(dedupeKey);
+          if (active && active.phase === "running" && active.runId) {
+            const state2 = running.get(active.groupKey);
+            if (state2) {
+              state2.writeQueue = state2.writeQueue.then(
+                () => options.sessions.appendGroupAlert(state2.runId, alert)
+              ).catch((err) => {
+                options.log(
+                  `Failed to attach re-page to group ${active.groupKey} (run ${state2.runId}): ${err}`
+                );
+              });
+            } else {
+              options.log(
+                `Suppression lookup hit but run vanished for dedupeKey ${dedupeKey}`
+              );
+            }
+          }
+          continue;
+        }
+        if (running.has(groupKey)) {
+          const state2 = running.get(groupKey);
+          if (state2) {
+            activeAlerts.set(dedupeKey, {
+              phase: "running",
+              groupKey,
+              runId: state2.runId
+            });
+            state2.dedupeKeys.add(dedupeKey);
+            state2.writeQueue = state2.writeQueue.then(() => options.sessions.appendGroupAlert(state2.runId, alert)).catch((err) => {
+              options.log(
+                `Failed to attach late alert to group ${groupKey} (run ${state2.runId}): ${err}`
+              );
+            });
+          }
+          continue;
+        }
+        if (windows.has(groupKey)) {
+          const state2 = windows.get(groupKey);
+          if (state2) {
+            activeAlerts.set(dedupeKey, { phase: "window", groupKey });
+            state2.alerts.push(alert);
+          }
+          continue;
+        }
+        const state = {
+          alerts: [alert],
+          timer: setTimeout(() => {
+            const alertsToRun = state.alerts;
+            windows.delete(groupKey);
+            const runId = randomUUID();
+            const dedupeKeys = /* @__PURE__ */ new Set();
+            for (const a of alertsToRun) {
+              const dkey = deriveDedupeKey(a);
+              activeAlerts.set(dkey, {
+                phase: "running",
+                groupKey,
+                runId
+              });
+              dedupeKeys.add(dkey);
+            }
+            const rec = {
+              groupKey,
+              formedBy: "window",
+              alerts: alertsToRun,
+              lateAlerts: []
+            };
+            const writePromise = Promise.resolve().then(() => options.sessions.writeGroupRecord(runId, rec)).catch((err) => {
+              options.log(
+                `Failed to write group record for group ${groupKey} (run ${runId}): ${err} \u2014 investigation will proceed without it`
+              );
+            });
+            running.set(groupKey, {
+              runId,
+              writeQueue: writePromise,
+              dedupeKeys
+            });
+            writePromise.then(async () => {
+              if (shuttingDown) {
+                running.delete(groupKey);
+                for (const key of dedupeKeys) {
+                  activeAlerts.delete(key);
+                }
+                return;
+              }
+              try {
+                await options.runInvestigation(runId, alertsToRun);
+              } catch (err) {
+                options.log(
+                  `Investigation for group ${groupKey} failed: ${err}`
+                );
+              } finally {
+                running.delete(groupKey);
+                for (const key of dedupeKeys) {
+                  activeAlerts.delete(key);
+                }
+              }
+            }).catch((err) => {
+              options.log(
+                `Investigation for group ${groupKey} failed: ${err}`
+              );
+              running.delete(groupKey);
+              for (const key of dedupeKeys) {
+                activeAlerts.delete(key);
+              }
+            });
+          }, options.windowMs)
+        };
+        activeAlerts.set(dedupeKey, { phase: "window", groupKey });
+        windows.set(groupKey, state);
+      }
+    },
+    shutdown() {
+      shuttingDown = true;
+      let dropped = 0;
+      for (const state of windows.values()) {
+        clearTimeout(state.timer);
+        dropped++;
+      }
+      windows.clear();
+      activeAlerts.clear();
+      if (dropped > 0) {
+        options.log(`Shutdown: dropped ${dropped} pending grouping windows`);
+      }
+    }
+  };
+}
+
+export {
+  deriveGroupKey,
+  deriveDedupeKey,
+  createGroupingLayer
+};

package/dist/chunk-TGP6QTFO.js

@@ -0,0 +1,156 @@
+import {
+  HARNESS_IDS,
+  PERMISSION_MODES,
+  SANDBOX_MODES
+} from "./chunk-5BT3XQOG.js";
+import {
+  llmProviderIdSchema
+} from "./chunk-XH6DIKTA.js";
+
+// src/config/schema.ts
+import { z } from "zod";
+var PermissionConfigSchema = z.object({
+  mode: z.enum(PERMISSION_MODES).default("read-only")
+});
+var HarnessNativeConfigSchema = z.object({
+  native: z.record(z.string(), z.unknown()).optional()
+});
+var AgentLimitsConfigSchema = z.object({
+  /** Wall-clock deadline (ms) — enforced by every sandbox provider. */
+  wall_clock_ms: z.number().int().positive().optional(),
+  /** Memory ceiling (MB) — best-effort (srt+systemd-run only). */
+  memory_mb: z.number().int().positive().optional(),
+  /** CPU quota (whole/fractional cores) — best-effort (srt+systemd-run only). */
+  cpu_cores: z.number().positive().optional()
+});
+var AgentConfigSchema = z.object({
+  default: z.enum(HARNESS_IDS).default("claude-code"),
+  /**
+   * BARE model id (e.g. "gpt-oss:120b") for the Tier-2 HARNESS ONLY — the chosen
+   * harness applies its own provider prefix (ADR-0017: deepagents prepends
+   * "openai:"; Claude Code takes it bare). Omit to let the harness pick its own
+   * default. The Tier-1 reduce model is a SEPARATE knob — `synth.model` (ADR-0013/
+   * 0016): the two calls go to different providers, so one key must never feed both.
+   */
+  model: z.string().optional(),
+  /** The posture dial (ADR-0017). Defaults to `read-only`. */
+  permissions: optionalWithDefaults(PermissionConfigSchema),
+  /**
+   * The isolation boundary the harness runs in (ADR-0020): `process` (the always-on
+   * cooperative floor), `srt` (enforced OS boundary), or `auto` (srt WHEN its egress
+   * bridge is healthy — the self-check, B.1.1 — else the floor; the degrade is honest,
+   * never silent). Defaults to `auto`: honest precisely BECAUSE of the self-check, which
+   * is what makes it safe to prefer the enforced boundary by default.
+   */
+  sandbox: z.enum(SANDBOX_MODES).default("auto"),
+  /**
+   * Best-effort resource caps for the sandboxed harness (ADR-0020). Optional; an
+   * omitted section means "no caps" (the object defaults to `{}` after parse).
+   */
+  limits: optionalWithDefaults(AgentLimitsConfigSchema),
+  /**
+   * Per-alert fan-out cap (ADR-0016 decision 2): the max branches the supervisor
+   * runs when a context carries multiple alerts. Optional — omitted ⇒ the engine
+   * default (3). A single-alert run always uses one branch regardless.
+   */
+  max_branches: z.number().int().positive().optional(),
+  max_turns: z.number().int().positive().optional()
+});
+var WorkspaceConfigSchema = z.object({
+  dir: z.string().default("~/.prismalens")
+});
+var ListenCapsConfigSchema = z.object({
+  /** Max investigations running at once. Default 2. */
+  max_concurrent: z.number().int().positive().default(2),
+  /** Max investigations started per trailing hour. Default 10. */
+  max_per_hour: z.number().int().positive().default(10),
+  /** Per-run turn ceiling for the default harness. Unset ⇒ the harness default. */
+  max_turns: z.number().int().positive().optional()
+});
+var ListenConfigSchema = z.object({
+  /** Local intake host. Default 127.0.0.1. */
+  host: z.string().default("127.0.0.1"),
+  /** Local intake port (4181: clear of 9090/9093/3000/8080 defaults). 0 = ephemeral. */
+  port: z.number().int().min(0).max(65535).default(4181),
+  /** Shared bearer token Alertmanager presents; unset ⇒ `pl listen` refuses to start. */
+  token: z.string().optional(),
+  /** Max alerts waiting or running at once; default 8. */
+  max_pending: z.number().int().positive().default(8),
+  /** Grouping window in milliseconds to debounce alerts into one investigation. */
+  grouping_window_ms: z.number().int().min(1e3).max(12e4).default(6e4),
+  /**
+   * Slack incoming-webhook URL for report delivery (issue #61). Optional — unset ⇒
+   * delivery disabled. Set via env interpolation (slack_webhook_url:
+   * "${PRISMALENS_SLACK_WEBHOOK_URL}") so the secret stays in env (ADR-0006).
+   */
+  slack_webhook_url: z.string().url().optional(),
+  /** Run-budget guardrails (issue #62). Always present with defaults after parse. */
+  caps: optionalWithDefaults(ListenCapsConfigSchema)
+});
+var TelemetryConfigSchema = z.object({
+  prometheus_url: z.string().optional(),
+  alertmanager_url: z.string().optional(),
+  api_url: z.string().optional()
+});
+var ServiceConfigSchema = z.object({
+  tier: z.string().optional(),
+  /** owner/name slug or a local path the harness reads. */
+  repo: z.string().optional(),
+  /** Direct dependency service names (blast-radius seed). */
+  depends_on: z.array(z.string()).default([])
+});
+var LogSourceConfigSchema = z.object({
+  kind: z.string().optional(),
+  url: z.string().optional()
+});
+var AlertSourceConfigSchema = z.record(
+  z.string(),
+  z.record(z.string(), z.string())
+);
+var RepoConfigSchema = z.object({
+  repo: z.string(),
+  local_path: z.string().nullable().default(null),
+  alert_sources: AlertSourceConfigSchema.optional()
+});
+function optionalWithDefaults(schema) {
+  return z.optional(z.record(z.string(), z.unknown())).transform((val, ctx) => {
+    const res = schema.safeParse(val ?? {});
+    if (!res.success) {
+      for (const issue of res.error.issues) {
+        ctx.addIssue(issue);
+      }
+      return z.NEVER;
+    }
+    return res.data;
+  });
+}
+var SynthConfigSchema = z.object({
+  provider: llmProviderIdSchema.optional(),
+  model: z.string().optional(),
+  base_url: z.string().url().optional()
+});
+var PlConfigSchema = z.object({
+  $schema: z.string().optional(),
+  /** Convenience single-repo default (owner/name); `repos` is the multi-repo map. */
+  repo: z.string().optional(),
+  repos: z.record(z.string(), RepoConfigSchema).optional().transform((val) => val ?? {}),
+  /** Service catalog (ADR-0015) — keyed by service name; maps into the context. */
+  services: z.record(z.string(), ServiceConfigSchema).optional().transform((val) => val ?? {}),
+  /** Read-only log-query system the harness may query. */
+  logs: optionalWithDefaults(LogSourceConfigSchema),
+  agent: optionalWithDefaults(AgentConfigSchema),
+  synth: optionalWithDefaults(SynthConfigSchema),
+  workspace: optionalWithDefaults(WorkspaceConfigSchema),
+  listen: optionalWithDefaults(ListenConfigSchema),
+  telemetry: optionalWithDefaults(TelemetryConfigSchema),
+  alert_sources: AlertSourceConfigSchema.optional().transform(
+    (val) => val ?? {}
+  ),
+  /** Per-harness native passthrough (ADR-0017), keyed by harness id. */
+  harnesses: z.record(z.string(), HarnessNativeConfigSchema).optional().transform((val) => val ?? {})
+});
+
+export {
+  AgentConfigSchema,
+  PlConfigSchema
+};

package/dist/chunk-V6M6ISKI.js

@@ -0,0 +1,161 @@
+import {
+  PlConfigSchema
+} from "./chunk-TGP6QTFO.js";
+
+// src/config/loader.ts
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, join, parse as parsePath, resolve } from "node:path";
+import consola from "consola";
+import envPaths from "env-paths";
+import { parse as parseYaml } from "yaml";
+import { ZodError } from "zod";
+var PROJECT_CONFIG_FILENAME = "prismalens.config.yaml";
+var PROJECT_LOCAL_CONFIG_FILENAME = "prismalens.config.local.yaml";
+var USER_CONFIG_FILENAME = "config.yaml";
+function findConfigFile(cwd = process.cwd()) {
+  let dir = resolve(cwd);
+  const { root } = parsePath(dir);
+  for (; ; ) {
+    const candidate = join(dir, PROJECT_CONFIG_FILENAME);
+    if (existsSync(candidate)) return candidate;
+    if (dir === root) return void 0;
+    dir = dirname(dir);
+  }
+}
+function userConfigFile() {
+  const candidate = join(
+    envPaths("prismalens", { suffix: "" }).config,
+    USER_CONFIG_FILENAME
+  );
+  return existsSync(candidate) ? candidate : void 0;
+}
+function projectLocalConfigFile(projectFile, cwd) {
+  const dir = projectFile ? dirname(projectFile) : resolve(cwd);
+  const candidate = join(dir, PROJECT_LOCAL_CONFIG_FILENAME);
+  return existsSync(candidate) ? candidate : void 0;
+}
+async function readYamlFile(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    return parseYaml(content) ?? {};
+  } catch (err) {
+    if (err.code === "ENOENT") return {};
+    throw err;
+  }
+}
+var ENV_VAR_PATTERN = /\$\{([^}]+)\}/g;
+function interpolateDeep(value) {
+  if (typeof value === "string") {
+    return value.replace(ENV_VAR_PATTERN, (_, name) => {
+      const v = process.env[name];
+      if (v === void 0) {
+        throw new Error(
+          `Config references unset environment variable "${name}" (as \${${name}})`
+        );
+      }
+      return v;
+    });
+  }
+  if (Array.isArray(value)) return value.map(interpolateDeep);
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = interpolateDeep(v);
+    return out;
+  }
+  return value;
+}
+function isObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function deepMerge(target, source) {
+  const out = { ...target };
+  for (const [k, sv] of Object.entries(source)) {
+    const tv = out[k];
+    out[k] = isObject(sv) && isObject(tv) ? deepMerge(tv, sv) : sv;
+  }
+  return out;
+}
+function applyCliOverrides(config, o) {
+  const patch = {};
+  const agent = {};
+  if (o.agent !== void 0) agent.default = o.agent;
+  if (o.model !== void 0) agent.model = o.model;
+  if (Object.keys(agent).length > 0) patch.agent = agent;
+  const telemetry = {};
+  if (o.prometheusUrl !== void 0) telemetry.prometheus_url = o.prometheusUrl;
+  if (o.alertmanagerUrl !== void 0)
+    telemetry.alertmanager_url = o.alertmanagerUrl;
+  if (o.apiUrl !== void 0) telemetry.api_url = o.apiUrl;
+  if (Object.keys(telemetry).length > 0) patch.telemetry = telemetry;
+  return deepMerge(config, patch);
+}
+function warnUnknownKeys(input, output, path = []) {
+  for (const key in input) {
+    if (!Object.hasOwn(output, key)) {
+      consola.warn(`Unknown config key ignored: ${[...path, key].join(".")}`);
+    } else if (isObject(input[key]) && isObject(output[key])) {
+      warnUnknownKeys(
+        input[key],
+        output[key],
+        [...path, key]
+      );
+    }
+  }
+}
+async function loadConfig(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  if (options.configPath) {
+    const resolvedPath = resolve(options.configPath);
+    if (!existsSync(resolvedPath)) {
+      throw new Error(`Configuration file not found: ${resolvedPath}`);
+    }
+  }
+  const userFile = userConfigFile();
+  const projectFile = options.configPath ? resolve(options.configPath) : findConfigFile(cwd);
+  const projectLocalFile = projectLocalConfigFile(projectFile, cwd);
+  let merged = {};
+  const readFiles = [];
+  if (userFile) {
+    merged = deepMerge(merged, await readYamlFile(userFile));
+    readFiles.push(userFile);
+  }
+  if (projectFile) {
+    merged = deepMerge(merged, await readYamlFile(projectFile));
+    readFiles.push(projectFile);
+  }
+  if (projectLocalFile && projectLocalFile !== projectFile) {
+    merged = deepMerge(merged, await readYamlFile(projectLocalFile));
+    readFiles.push(projectLocalFile);
+  }
+  if (options.cliOverrides) {
+    merged = applyCliOverrides(merged, options.cliOverrides);
+  }
+  const interpolated = interpolateDeep(merged);
+  let config;
+  let attribution = "in config";
+  if (readFiles.length === 1) {
+    attribution = `in ${readFiles[0]}`;
+  } else if (readFiles.length > 1) {
+    attribution = `(merged from: ${readFiles.join(", ")})`;
+  }
+  try {
+    config = PlConfigSchema.parse(interpolated);
+    warnUnknownKeys(interpolated, config);
+  } catch (err) {
+    if (err instanceof ZodError) {
+      const issues = err.issues.map(
+        (i) => `${i.path.length > 0 ? i.path.join(".") : "<root>"}: ${i.message}`
+      ).join("\n");
+      throw new Error(`Invalid configuration ${attribution}:
+${issues}`);
+    }
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid PrismaLens configuration: ${detail}`);
+  }
+  return Object.freeze(config);
+}
+
+export {
+  loadConfig
+};

package/dist/chunk-XH6DIKTA.js

@@ -0,0 +1,83 @@
+// ../@prismalens/config/dist/providers/llm.js
+import { z } from "zod";
+var LLM_PROVIDERS = {
+  anthropic: {
+    id: "anthropic",
+    name: "Anthropic",
+    helpUrl: "https://console.anthropic.com/settings/keys",
+    defaultModel: "claude-sonnet-5",
+    envVar: "ANTHROPIC_API_KEY",
+    logoUrl: "https://models.dev/logos/anthropic.svg",
+    allowedHosts: ["api.anthropic.com"]
+  },
+  openai: {
+    id: "openai",
+    name: "OpenAI",
+    helpUrl: "https://platform.openai.com/api-keys",
+    defaultModel: "gpt-5.4-mini",
+    envVar: "OPENAI_API_KEY",
+    logoUrl: "https://models.dev/logos/openai.svg",
+    allowedHosts: ["api.openai.com"]
+  },
+  google: {
+    id: "google",
+    name: "Google Gemini",
+    helpUrl: "https://aistudio.google.com",
+    defaultModel: "gemini-3.5-flash",
+    envVar: "GOOGLE_API_KEY",
+    logoUrl: "https://models.dev/logos/google.svg",
+    allowedHosts: ["generativelanguage.googleapis.com"]
+  },
+  ollama: {
+    id: "ollama",
+    name: "Ollama",
+    helpUrl: "https://ollama.ai",
+    defaultModel: "gpt-oss:20b-cloud",
+    envVar: "OLLAMA_API_KEY",
+    // Optional — for Ollama Cloud
+    baseUrlRequired: false,
+    defaultBaseUrl: "http://localhost:11434/v1",
+    cloudBaseUrl: "https://ollama.com",
+    logoUrl: "https://models.dev/logos/ollama.svg",
+    allowedHosts: ["localhost", "127.0.0.1", "::1", "ollama.com"]
+  },
+  groq: {
+    id: "groq",
+    name: "Groq",
+    helpUrl: "https://console.groq.com/keys",
+    defaultModel: "openai/gpt-oss-120b",
+    envVar: "GROQ_API_KEY",
+    free: true,
+    logoUrl: "https://models.dev/logos/groq.svg",
+    allowedHosts: ["api.groq.com"]
+  },
+  custom: {
+    id: "custom",
+    name: "Custom (OpenAI)",
+    helpUrl: "https://platform.openai.com/docs/api-reference",
+    defaultModel: null,
+    envVar: "CUSTOM_LLM_API_KEY",
+    baseUrlRequired: true,
+    defaultBaseUrl: "http://localhost:8000/v1",
+    logoUrl: null,
+    allowedHosts: null
+  }
+};
+var LLM_PROVIDER_IDS = Object.keys(LLM_PROVIDERS);
+var AUTO_SELECT_PROVIDER_IDS = LLM_PROVIDER_IDS.filter((id) => id !== "custom");
+var LLM_CREDENTIAL_ENV_VARS = Object.values(LLM_PROVIDERS).map((provider) => provider.envVar);
+var llmProviderIdSchema = z.enum(LLM_PROVIDER_IDS);
+function getApiKeyEnvVar(providerId) {
+  return LLM_PROVIDERS[providerId].envVar;
+}
+function getDefaultModel(providerId) {
+  return LLM_PROVIDERS[providerId].defaultModel;
+}
+
+export {
+  LLM_PROVIDERS,
+  AUTO_SELECT_PROVIDER_IDS,
+  llmProviderIdSchema,
+  getApiKeyEnvVar,
+  getDefaultModel
+};