prismalens 0.2.0 → 0.4.0

package/dist/chunk-6N4PHBII.js

@@ -0,0 +1,30 @@
+// ../@prismalens/config/dist/investigation.js
+var TELEMETRY_DEFAULTS = {
+  prometheusUrl: "http://localhost:9090",
+  alertmanagerUrl: "http://localhost:9093",
+  apiUrl: "http://localhost:5000"
+};
+var SYNTH_DEFAULTS = {
+  /** OpenAI-compatible endpoint — note the `/v1`, which the AI SDK requires. */
+  baseURL: "https://ollama.com/v1"
+};
+var HARNESS_INIT_TIMEOUT_MS = 12e4;
+var HARNESS_PROMPT_TIMEOUT_MS = 18e4;
+var HARNESS_WALL_CLOCK_MS = 9e5;
+var PREVIEW_LIMIT = 4e3;
+var PREVIEW_CAP = 1200;
+var TRANSCRIPT_CAP = 24e3;
+var INVESTIGATION_DEFAULTS = {
+  telemetry: TELEMETRY_DEFAULTS,
+  synth: SYNTH_DEFAULTS,
+  harnessInitTimeoutMs: HARNESS_INIT_TIMEOUT_MS,
+  harnessPromptTimeoutMs: HARNESS_PROMPT_TIMEOUT_MS,
+  harnessWallClockMs: HARNESS_WALL_CLOCK_MS,
+  previewLimit: PREVIEW_LIMIT,
+  previewCap: PREVIEW_CAP,
+  transcriptCap: TRANSCRIPT_CAP
+};
+
+export {
+  INVESTIGATION_DEFAULTS
+};

package/dist/chunk-CTKCK7QT.js

@@ -0,0 +1,387 @@
+import {
+  getAppDataDir
+} from "./chunk-2Z7QZSIS.js";
+
+// src/core/session.ts
+import { homedir } from "node:os";
+import { join as join2, resolve } from "node:path";
+
+// src/core/db.ts
+import { existsSync, mkdirSync, renameSync } from "node:fs";
+import { join } from "node:path";
+var DatabaseSync;
+try {
+  const mod = await import("node:sqlite");
+  DatabaseSync = mod.DatabaseSync;
+} catch {
+  console.error("PrismaLens requires Node >= 22.13.");
+  process.exit(1);
+}
+var SCHEMA = `
+		PRAGMA journal_mode = WAL;
+		PRAGMA busy_timeout = 5000;
+		PRAGMA foreign_keys = ON;
+
+		CREATE TABLE IF NOT EXISTS groups (
+			id         TEXT PRIMARY KEY,
+			group_key  TEXT,
+			formed_by  TEXT NOT NULL DEFAULT 'window',
+			created_at TEXT NOT NULL
+		);
+
+		CREATE TABLE IF NOT EXISTS runs (
+			run_id         TEXT PRIMARY KEY,
+			group_id       TEXT REFERENCES groups(id),
+			status         TEXT NOT NULL CHECK (status IN ('running','done','errored','suppressed')),
+			alertname      TEXT,
+			agent          TEXT,
+			repo           TEXT,
+			workspace_path TEXT NOT NULL,
+			error          TEXT,
+			suppression_reason TEXT,
+			created_at     TEXT NOT NULL,
+			updated_at     TEXT NOT NULL,
+			completed_at   TEXT
+		);
+		CREATE INDEX IF NOT EXISTS idx_runs_created_at ON runs(created_at DESC);
+		CREATE INDEX IF NOT EXISTS idx_runs_status     ON runs(status);
+
+		CREATE TABLE IF NOT EXISTS events (
+			id      INTEGER PRIMARY KEY AUTOINCREMENT,
+			run_id  TEXT NOT NULL REFERENCES runs(run_id),
+			payload TEXT NOT NULL
+		);
+		CREATE INDEX IF NOT EXISTS idx_events_run ON events(run_id, id);
+
+		CREATE TABLE IF NOT EXISTS reports (
+			run_id  TEXT PRIMARY KEY REFERENCES runs(run_id),
+			payload TEXT NOT NULL
+		);
+
+		-- One row per alert attached to a group, in insertion order (rowid).
+		-- late = 0 for the alerts that formed the window, 1 for alerts that
+		-- attached while the group's run was already in flight.
+		CREATE TABLE IF NOT EXISTS group_alerts (
+			id       INTEGER PRIMARY KEY AUTOINCREMENT,
+			group_id TEXT NOT NULL REFERENCES groups(id),
+			late     INTEGER NOT NULL,
+			payload  TEXT NOT NULL
+		);
+		CREATE INDEX IF NOT EXISTS idx_group_alerts ON group_alerts(group_id, id);
+`;
+var SCHEMA_CHECK = `
+		SELECT id, group_key, formed_by, created_at FROM groups LIMIT 1;
+		SELECT run_id, group_id, status, alertname, agent, repo, workspace_path, error, suppression_reason, created_at, updated_at, completed_at FROM runs LIMIT 1;
+		SELECT id, run_id, payload FROM events LIMIT 1;
+		SELECT run_id, payload FROM reports LIMIT 1;
+		SELECT id, group_id, late, payload FROM group_alerts LIMIT 1;
+`;
+function openDatabase(baseDir) {
+  mkdirSync(baseDir, { recursive: true });
+  const dbPath = join(baseDir, "prismalens.db");
+  let db = new DatabaseSync(dbPath);
+  try {
+    db.exec(SCHEMA);
+    db.exec(SCHEMA_CHECK);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (!/no such column|no such table|has no column named/i.test(msg)) {
+      try {
+        db.close();
+      } catch {
+      }
+      throw err;
+    }
+    const backupPath = join(baseDir, `prismalens.db.bak-${Date.now()}`);
+    if (existsSync(`${dbPath}-wal`))
+      renameSync(`${dbPath}-wal`, `${backupPath}-wal`);
+    if (existsSync(`${dbPath}-shm`))
+      renameSync(`${dbPath}-shm`, `${backupPath}-shm`);
+    db.close();
+    renameSync(dbPath, backupPath);
+    console.warn(
+      `[!] Workspace schema is incompatible. Backed up old database to ${backupPath} and recreated.`
+    );
+    db = new DatabaseSync(dbPath);
+    db.exec(SCHEMA);
+  }
+  return db;
+}
+
+// src/core/sqlite-session-store.ts
+function tx(db, fn) {
+  db.exec("BEGIN");
+  try {
+    const r = fn();
+    db.exec("COMMIT");
+    return r;
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+}
+function mapRun(row) {
+  const record = {
+    runId: row.run_id,
+    status: row.status,
+    workspacePath: row.workspace_path,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+  if (row.alertname) record.alertname = row.alertname;
+  if (row.agent) record.agent = row.agent;
+  if (row.repo) record.repo = row.repo;
+  if (row.error) record.error = row.error;
+  if (row.suppression_reason) record.suppressionReason = row.suppression_reason;
+  if (row.completed_at) record.completedAt = row.completed_at;
+  return record;
+}
+var SqliteSessionManager = class {
+  constructor(baseDir, db, workspaceDir, assertRunId) {
+    this.baseDir = baseDir;
+    this.db = db;
+    this.workspaceDir = workspaceDir;
+    this.assertRunId = assertRunId;
+  }
+  baseDir;
+  db;
+  workspaceDir;
+  assertRunId;
+  async create(input) {
+    this.assertRunId(input.runId);
+    const dir = this.workspaceDir(input.runId);
+    const { mkdirSync: mkdirSync2 } = await import("node:fs");
+    mkdirSync2(dir, { recursive: true });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return tx(this.db, () => {
+      const insertGroup = this.db.prepare(`
+				INSERT INTO groups (id, formed_by, created_at)
+				VALUES (?, 'window', ?)
+				ON CONFLICT DO NOTHING
+			`);
+      insertGroup.run(input.runId, now);
+      const insertRun = this.db.prepare(`
+				INSERT INTO runs (
+					run_id, group_id, status, alertname, agent, repo,
+					workspace_path, created_at, updated_at
+				) VALUES (?, ?, 'running', ?, ?, ?, ?, ?, ?)
+			`);
+      insertRun.run(
+        input.runId,
+        input.runId,
+        input.alertname ?? null,
+        input.agent ?? null,
+        input.repo ?? null,
+        dir,
+        now,
+        now
+      );
+      const getRun = this.db.prepare("SELECT * FROM runs WHERE run_id = ?");
+      const row = getRun.get(input.runId);
+      if (!row) throw new Error("Failed to read back created session");
+      return mapRun(row);
+    });
+  }
+  async get(runId) {
+    this.assertRunId(runId);
+    const getRun = this.db.prepare("SELECT * FROM runs WHERE run_id = ?");
+    const row = getRun.get(runId);
+    return row ? mapRun(row) : null;
+  }
+  async update(runId, updates) {
+    this.assertRunId(runId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return tx(this.db, () => {
+      const existingStmt = this.db.prepare(
+        "SELECT * FROM runs WHERE run_id = ?"
+      );
+      const existing = existingStmt.get(runId);
+      if (!existing) throw new Error(`Session "${runId}" not found`);
+      const status = updates.status ?? existing.status;
+      const alertname = updates.alertname !== void 0 ? updates.alertname : existing.alertname;
+      const agent = updates.agent !== void 0 ? updates.agent : existing.agent;
+      const repo = updates.repo !== void 0 ? updates.repo : existing.repo;
+      const error = updates.error !== void 0 ? updates.error : existing.error;
+      const completedAt = updates.completedAt !== void 0 ? updates.completedAt : existing.completed_at;
+      const updateStmt = this.db.prepare(`
+				UPDATE runs SET
+					status = ?,
+					alertname = ?,
+					agent = ?,
+					repo = ?,
+					error = ?,
+					completed_at = ?,
+					updated_at = ?
+				WHERE run_id = ?
+			`);
+      const res = updateStmt.run(
+        status,
+        alertname ?? null,
+        agent ?? null,
+        repo ?? null,
+        error ?? null,
+        completedAt ?? null,
+        now,
+        runId
+      );
+      if (res.changes === 0) {
+        throw new Error(`Session "${runId}" not found`);
+      }
+      const row = existingStmt.get(runId);
+      if (!row) throw new Error("Failed to read back updated session");
+      return mapRun(row);
+    });
+  }
+  async list(filter) {
+    let query = "SELECT * FROM runs";
+    let params = [];
+    if (filter?.status && filter.status.length > 0) {
+      const placeholders = filter.status.map(() => "?").join(",");
+      query += ` WHERE status IN (${placeholders})`;
+      params = [...filter.status];
+    }
+    query += " ORDER BY created_at DESC, rowid DESC";
+    const stmt = this.db.prepare(query);
+    const rows = stmt.all(...params);
+    return rows.map(mapRun);
+  }
+  async appendEvent(runId, event) {
+    const stmt = this.db.prepare(
+      "INSERT INTO events(run_id, payload) VALUES(?, ?)"
+    );
+    stmt.run(runId, JSON.stringify(event));
+  }
+  async readEvents(runId) {
+    const stmt = this.db.prepare(
+      "SELECT payload FROM events WHERE run_id = ? ORDER BY id"
+    );
+    const rows = stmt.all(runId);
+    return rows.map((r) => JSON.parse(r.payload));
+  }
+  async writeReport(runId, report) {
+    const stmt = this.db.prepare(`
+			INSERT INTO reports (run_id, payload)
+			VALUES (?, ?)
+			ON CONFLICT(run_id) DO UPDATE SET payload=excluded.payload
+		`);
+    stmt.run(runId, JSON.stringify(report));
+  }
+  async readReport(runId) {
+    try {
+      const stmt = this.db.prepare(
+        "SELECT payload FROM reports WHERE run_id = ?"
+      );
+      const row = stmt.get(runId);
+      if (!row) return null;
+      return JSON.parse(row.payload);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Persist a group's record (ADR-0012 grouping): upsert the `groups` row with
+   * the key + how it formed (taken from the record, never hardcoded), then
+   * replace its `group_alerts` with the formative alerts (late=0) followed by
+   * any already-attached late alerts (late=1), each in order. The group row may
+   * already exist (a plain `create()` seeds one) — we keep its created_at.
+   */
+  async writeGroupRecord(runId, rec) {
+    this.assertRunId(runId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    tx(this.db, () => {
+      this.db.prepare(`
+					INSERT INTO groups (id, group_key, formed_by, created_at)
+					VALUES (?, ?, ?, ?)
+					ON CONFLICT(id) DO UPDATE SET
+						group_key = excluded.group_key,
+						formed_by = excluded.formed_by
+				`).run(runId, rec.groupKey, rec.formedBy, now);
+      this.db.prepare("DELETE FROM group_alerts WHERE group_id = ?").run(runId);
+      const insertAlert = this.db.prepare(
+        "INSERT INTO group_alerts (group_id, late, payload) VALUES (?, ?, ?)"
+      );
+      for (const alert of rec.alerts) {
+        insertAlert.run(runId, 0, JSON.stringify(alert));
+      }
+      for (const alert of rec.lateAlerts) {
+        insertAlert.run(runId, 1, JSON.stringify(alert));
+      }
+    });
+  }
+  /** Attach a late alert to an existing group, appended in arrival order. */
+  async appendGroupAlert(runId, alert) {
+    this.assertRunId(runId);
+    tx(this.db, () => {
+      const group = this.db.prepare("SELECT id FROM groups WHERE id = ?").get(runId);
+      if (!group) {
+        throw new Error(
+          `Cannot append alert to missing group for run ${runId}`
+        );
+      }
+      this.db.prepare(
+        "INSERT INTO group_alerts (group_id, late, payload) VALUES (?, 1, ?)"
+      ).run(runId, JSON.stringify(alert));
+    });
+  }
+  async recordSuppressed(input) {
+    this.assertRunId(input.runId);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    tx(this.db, () => {
+      this.db.prepare(`
+					INSERT INTO groups (id, formed_by, created_at)
+					VALUES (?, 'window', ?)
+					ON CONFLICT DO NOTHING
+				`).run(input.runId, now);
+      this.db.prepare(`
+					INSERT INTO runs (
+						run_id, group_id, status, alertname,
+						workspace_path, suppression_reason,
+						created_at, updated_at, completed_at
+					) VALUES (?, ?, 'suppressed', ?, '', ?, ?, ?, ?)
+				`).run(
+        input.runId,
+        input.runId,
+        input.alertname ?? null,
+        input.reason,
+        now,
+        now,
+        now
+      );
+    });
+  }
+  /** Release the underlying db handle. Callers that own a transient manager
+   * (e.g. one per `pl listen` run) must close it or leak a connection. */
+  close() {
+    this.db.close();
+  }
+};
+
+// src/core/session.ts
+var RUN_ID_RE = /^[a-zA-Z0-9_-]{1,128}$/;
+function expandHome(p) {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/")) return join2(homedir(), p.slice(2));
+  return p;
+}
+function resolveBaseDir(baseDir) {
+  if (!baseDir || baseDir === "~/.prismalens") return getAppDataDir();
+  return resolve(expandHome(baseDir));
+}
+function createSessionManager(baseDir) {
+  const base = resolveBaseDir(baseDir);
+  const db = openDatabase(base);
+  const runsRoot = join2(base, "runs");
+  function assertRunId(runId) {
+    if (!RUN_ID_RE.test(runId)) throw new Error(`Invalid runId: "${runId}"`);
+  }
+  function workspaceDir(runId) {
+    assertRunId(runId);
+    return join2(runsRoot, runId);
+  }
+  return new SqliteSessionManager(base, db, workspaceDir, assertRunId);
+}
+
+export {
+  resolveBaseDir,
+  createSessionManager
+};

package/dist/chunk-CVSS5JPC.js

@@ -0,0 +1,130 @@
+import {
+  LLM_PROVIDERS,
+  getApiKeyEnvVar
+} from "./chunk-XH6DIKTA.js";
+import {
+  ensureAppDataDir,
+  getAppDataDir
+} from "./chunk-2Z7QZSIS.js";
+
+// ../@prismalens/config/dist/auth-store.js
+import { chmodSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import consola from "consola";
+var AUTH_FILE_NAME = "auth.json";
+function getAuthFilePath() {
+  return join(getAppDataDir(), AUTH_FILE_NAME);
+}
+function readAuthStore() {
+  const file = getAuthFilePath();
+  try {
+    const stat = statSync(file);
+    if ((stat.mode & 511) !== 384) {
+      chmodSync(file, 384);
+    }
+    const content = readFileSync(file, "utf-8");
+    return JSON.parse(content);
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && (err.code === "EACCES" || err.code === "EPERM")) {
+      consola.warn("Auth store file is inaccessible due to permissions. Treating as empty.");
+      return {};
+    }
+    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+      return {};
+    }
+    if (err instanceof SyntaxError) {
+      consola.warn("Auth store file is corrupted. Treating as empty.");
+      return {};
+    }
+    throw err;
+  }
+}
+function writeAuthStore(store) {
+  const file = getAuthFilePath();
+  ensureAppDataDir();
+  const tmpFile = `${file}.tmp`;
+  writeFileSync(tmpFile, JSON.stringify(store, null, 2), { mode: 384 });
+  renameSync(tmpFile, file);
+}
+function setStoredCredential(provider, key) {
+  const store = readAuthStore();
+  store[provider] = { type: "api", key };
+  writeAuthStore(store);
+}
+function removeStoredCredential(provider) {
+  const store = readAuthStore();
+  delete store[provider];
+  writeAuthStore(store);
+}
+function getStoredCredential(provider) {
+  const store = readAuthStore();
+  return store[provider]?.key;
+}
+
+// ../@prismalens/config/dist/env/readers.js
+import { readFileSync as readFileSync2 } from "node:fs";
+function readEnv(name) {
+  if (process.env[name] !== void 0) {
+    return process.env[name];
+  }
+  const filePath = process.env[`${name}_FILE`];
+  if (filePath) {
+    try {
+      return readFileSync2(filePath, "utf-8").replace(/\r?\n$/, "");
+    } catch (error) {
+      throw new Error(`Failed to read ${name} from file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return void 0;
+}
+
+// ../@prismalens/config/dist/credentials.js
+function ensureV1(baseURL) {
+  const trimmed = baseURL.replace(/\/$/, "");
+  if (trimmed.endsWith("/v1"))
+    return trimmed;
+  return `${trimmed}/v1`;
+}
+function resolveCredentials(providerId, configBaseUrl) {
+  const envVar = getApiKeyEnvVar(providerId);
+  let apiKey;
+  let source = "none";
+  if (process.env[envVar]?.trim()) {
+    apiKey = process.env[envVar];
+    source = "env";
+  } else if (process.env[`${envVar}_FILE`]?.trim()) {
+    apiKey = readEnv(envVar);
+    apiKey = apiKey?.trim() ? apiKey : void 0;
+    source = apiKey ? "file" : "none";
+  } else {
+    const storedKey = getStoredCredential(providerId);
+    if (storedKey?.trim()) {
+      apiKey = storedKey;
+      source = "stored";
+    }
+  }
+  const provider = LLM_PROVIDERS[providerId];
+  let baseURL = configBaseUrl;
+  if (!baseURL) {
+    baseURL = process.env[`${provider.id.toUpperCase()}_BASE_URL`];
+  }
+  if (!baseURL && providerId !== "custom" && "defaultBaseUrl" in provider) {
+    baseURL = provider.defaultBaseUrl;
+  }
+  if (baseURL && (providerId === "openai" || providerId === "custom" || providerId === "ollama")) {
+    baseURL = ensureV1(baseURL);
+  }
+  return {
+    providerId,
+    source,
+    ...apiKey !== void 0 ? { apiKey } : {},
+    ...baseURL !== void 0 ? { baseURL } : {}
+  };
+}
+
+export {
+  setStoredCredential,
+  removeStoredCredential,
+  ensureV1,
+  resolveCredentials
+};

package/dist/chunk-HPE5CTO4.js

@@ -0,0 +1,22 @@
+// src/version.ts
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function cliVersion() {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 4; i++) {
+    try {
+      const pkg = JSON.parse(
+        readFileSync(join(dir, "package.json"), "utf8")
+      );
+      if (pkg.name === "prismalens" && pkg.version) return pkg.version;
+    } catch {
+    }
+    dir = dirname(dir);
+  }
+  return "0.0.0";
+}
+
+export {
+  cliVersion
+};

package/dist/chunk-PTBCAI34.js

@@ -0,0 +1,34 @@
+// src/cli/flags.ts
+import consola from "consola";
+function kebabToCamel(str) {
+  return str.replace(/-([a-z])/g, (_, g) => g.toUpperCase());
+}
+function camelToKebab(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function assertKnownFlags(args, cmd) {
+  const declaredArgs = cmd?.args || {};
+  const allowedKeys = /* @__PURE__ */ new Set(["_"]);
+  for (const key in declaredArgs) {
+    if (Object.hasOwn(declaredArgs, key)) {
+      allowedKeys.add(key);
+      allowedKeys.add(kebabToCamel(key));
+      allowedKeys.add(camelToKebab(key));
+    }
+  }
+  for (const key in args) {
+    if (Object.hasOwn(args, key)) {
+      if (!allowedKeys.has(key)) {
+        consola.error(`Unknown option: --${key}`);
+        const rawArgs = process.argv.slice(2);
+        const cmdName = `pl${rawArgs[0] && !rawArgs[0].startsWith("-") ? ` ${rawArgs[0]}` : ""}`;
+        consola.info(`Run \`${cmdName} --help\` for usage.`);
+        process.exit(1);
+      }
+    }
+  }
+}
+
+export {
+  assertKnownFlags
+};