prismalens 0.3.0 → 0.4.0

package/dist/src/cli/report.js

@@ -1,73 +1,76 @@
-// SPDX-License-Identifier: Apache-2.0
-// Copyright 2026 Sumit Patel
+import {
+  createSessionManager
+} from "../../chunk-CTKCK7QT.js";
+import {
+  assertKnownFlags
+} from "../../chunk-PTBCAI34.js";
+import "../../chunk-6N4PHBII.js";
+import "../../chunk-2Z7QZSIS.js";
+
+// src/cli/report.ts
 import { defineCommand } from "citty";
 import consola from "consola";
-import { createSessionManager } from "../core/session.js";
-import { assertKnownFlags } from "./flags.js";
-export default defineCommand({
-    meta: {
-        name: "report",
-        description: "Print a stored report for a given run ID\n\nExamples:\n  $ pl report 1234abcd\n  $ pl report 1234abcd --json\n  $ pl report 1234abcd --events",
+var report_default = defineCommand({
+  meta: {
+    name: "report",
+    description: "Print a stored report for a given run ID\n\nExamples:\n  $ pl report 1234abcd\n  $ pl report 1234abcd --json\n  $ pl report 1234abcd --events"
+  },
+  args: {
+    id: {
+      type: "positional",
+      description: "The run ID",
+      required: true
     },
-    args: {
-        id: {
-            type: "positional",
-            description: "The run ID",
-            required: true,
-        },
-        events: {
-            type: "boolean",
-            description: "Include timeline events",
-            required: false,
-        },
-        "workspace-dir": {
-            type: "string",
-            description: "Workspace directory (default: ~/.prismalens; overridden by PRISMALENS_WORKSPACE_DIR)",
-            required: false,
-        },
-        json: {
-            type: "boolean",
-            description: "Print machine-readable JSON",
-            required: false,
-        },
+    events: {
+      type: "boolean",
+      description: "Include timeline events",
+      required: false
     },
-    async run({ args, cmd }) {
-        let sessions;
-        try {
-            assertKnownFlags(args, cmd);
-            sessions = createSessionManager(args["workspace-dir"]);
-            const json = Boolean(args.json);
-            const report = await sessions.readReport(args.id);
-            if (!report) {
-                consola.error(`No report for run ${args.id}`);
-                // exitCode (not process.exit) so the finally block still closes the
-                // session manager before the process tears down.
-                process.exitCode = 1;
-                return;
-            }
-            if (json) {
-                const out = args.events
-                    ? { report, events: await sessions.readEvents(args.id) }
-                    : report;
-                process.stdout.write(`${JSON.stringify(out, null, 2)}\n`);
-                return;
-            }
-            consola.log(JSON.stringify(report, null, 2));
-            if (args.events) {
-                const events = await sessions.readEvents(args.id);
-                consola.log("\n--- Timeline Events ---");
-                for (const ev of events) {
-                    consola.log(JSON.stringify(ev));
-                }
-            }
-        }
-        catch (err) {
-            consola.error("Failed to read report:", err);
-            process.exitCode = 1;
-        }
-        finally {
-            sessions?.close?.();
-        }
+    "workspace-dir": {
+      type: "string",
+      description: "Workspace directory (default: ~/.prismalens; overridden by PRISMALENS_WORKSPACE_DIR)",
+      required: false
     },
+    json: {
+      type: "boolean",
+      description: "Print machine-readable JSON",
+      required: false
+    }
+  },
+  async run({ args, cmd }) {
+    let sessions;
+    try {
+      assertKnownFlags(args, cmd);
+      sessions = createSessionManager(args["workspace-dir"]);
+      const json = Boolean(args.json);
+      const report = await sessions.readReport(args.id);
+      if (!report) {
+        consola.error(`No report for run ${args.id}`);
+        process.exitCode = 1;
+        return;
+      }
+      if (json) {
+        const out = args.events ? { report, events: await sessions.readEvents(args.id) } : report;
+        process.stdout.write(`${JSON.stringify(out, null, 2)}
+`);
+        return;
+      }
+      consola.log(JSON.stringify(report, null, 2));
+      if (args.events) {
+        const events = await sessions.readEvents(args.id);
+        consola.log("\n--- Timeline Events ---");
+        for (const ev of events) {
+          consola.log(JSON.stringify(ev));
+        }
+      }
+    } catch (err) {
+      consola.error("Failed to read report:", err);
+      process.exitCode = 1;
+    } finally {
+      sessions?.close?.();
+    }
+  }
 });
-//# sourceMappingURL=report.js.map
+export {
+  report_default as default
+};

package/dist/src/cli/serve.js

@@ -1,35 +1,265 @@
-// SPDX-License-Identifier: Apache-2.0
-// Copyright 2026 Sumit Patel
-/**
- * `prismalens serve` — run the JSON-RPC 2.0 server over stdio (ADR-0007/0010).
- *
- * This is the LIVE channel (replacing file-read): the desktop app / API spawn
- * `prismalens serve`, call `initialize` + `investigate`, and consume
- * `investigate/event` notifications as the Tier-1 supervisor streams. The
- * ~/.prismalens workspace stays the durable record (events.jsonl + report.json),
- * written exactly as the `investigate` command writes it.
- */
+import {
+  cliVersion
+} from "../../chunk-HPE5CTO4.js";
+import {
+  createFileSessionStore,
+  resolveRepoSlug,
+  resolveRunSandbox
+} from "../../chunk-PVQVFRIV.js";
+import {
+  loadConfig
+} from "../../chunk-V6M6ISKI.js";
+import {
+  createSessionManager
+} from "../../chunk-CTKCK7QT.js";
+import {
+  resolveInvestigation
+} from "../../chunk-QDK5PAI3.js";
+import "../../chunk-CVSS5JPC.js";
+import "../../chunk-TGP6QTFO.js";
+import {
+  assertKnownFlags
+} from "../../chunk-PTBCAI34.js";
+import {
+  SANDBOX_MODES,
+  conductRun
+} from "../../chunk-5BT3XQOG.js";
+import "../../chunk-6N4PHBII.js";
+import "../../chunk-XH6DIKTA.js";
+import "../../chunk-2Z7QZSIS.js";
+
+// src/cli/serve.ts
 import { defineCommand } from "citty";
 import { consola } from "consola";
-import { runJsonRpcServer } from "../jsonrpc/server.js";
-import { cliVersion } from "../version.js";
-import { assertKnownFlags } from "./flags.js";
-/** Reported as serverInfo.version by `initialize` (matches the CLI's meta.version). */
-const SERVER_VERSION = cliVersion();
-export default defineCommand({
-    meta: {
-        name: "serve",
-        description: "Run the JSON-RPC 2.0 server over stdio (the LIVE channel for the desktop app / API).\n\nExamples:\n  $ pl serve",
-    },
-    async run({ args, cmd }) {
-        try {
-            assertKnownFlags(args, cmd);
-            await runJsonRpcServer({ version: SERVER_VERSION });
+
+// src/jsonrpc/server.ts
+import { randomUUID } from "node:crypto";
+import { resolve } from "node:path";
+import { createInterface } from "node:readline";
+import {
+  JSONRPCErrorException,
+  JSONRPCServer
+} from "json-rpc-2.0";
+var PROTOCOL_VERSION = 1;
+var PARSE_ERROR = -32700;
+var INVALID_PARAMS = -32602;
+var INTERNAL_ERROR = -32603;
+var NO_EVIDENCE = -32e3;
+function isRecord(x) {
+  return x !== null && typeof x === "object" && !Array.isArray(x);
+}
+function str(x) {
+  return typeof x === "string" ? x : void 0;
+}
+function parseInvestigateParams(raw) {
+  const p = isRecord(raw) ? raw : {};
+  const out = {};
+  if (isRecord(p.alert)) out.alert = p.alert;
+  const query = str(p.query);
+  if (query) out.query = query;
+  const repo = str(p.repo);
+  if (repo) out.repo = repo;
+  const harness = str(p.harness);
+  if (harness) out.harness = harness;
+  const model = str(p.model);
+  if (model) out.model = model;
+  const config = str(p.config);
+  if (config) out.config = config;
+  const service = str(p.service);
+  if (service) out.service = service;
+  const mode = str(p.mode);
+  if (mode) out.mode = mode;
+  if (typeof p.dangerouslySkipPermissions === "boolean") {
+    out.dangerouslySkipPermissions = p.dangerouslySkipPermissions;
+  }
+  if (p.sandbox !== void 0) {
+    const sandbox = str(p.sandbox);
+    if (!sandbox || !SANDBOX_MODES.includes(sandbox)) {
+      throw new JSONRPCErrorException(
+        `Invalid sandbox mode ${JSON.stringify(p.sandbox)}. Expected one of: ${SANDBOX_MODES.join(", ")}.`,
+        INVALID_PARAMS
+      );
+    }
+    out.sandbox = sandbox;
+  }
+  if (p.maxTurns !== void 0) {
+    if (typeof p.maxTurns !== "number" || !Number.isInteger(p.maxTurns) || p.maxTurns <= 0) {
+      throw new JSONRPCErrorException(
+        `Invalid maxTurns ${JSON.stringify(p.maxTurns)}. Expected a positive integer.`,
+        INVALID_PARAMS
+      );
+    }
+    out.maxTurns = p.maxTurns;
+  }
+  return out;
+}
+async function runJsonRpcServer(options) {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const write = (message) => {
+    output.write(`${JSON.stringify(message)}
+`);
+  };
+  const notify = (method, params) => {
+    write({ jsonrpc: "2.0", method, params });
+  };
+  const handleInitialize = () => ({
+    protocolVersion: PROTOCOL_VERSION,
+    serverInfo: { name: "prismalens", version: options.version }
+  });
+  const handleInvestigate = async (rawParams) => {
+    const params = parseInvestigateParams(rawParams);
+    const cwd = params.repo ? resolve(params.repo) : process.cwd();
+    const config = await loadConfig({
+      ...params.config ? { configPath: params.config } : {},
+      cwd,
+      cliOverrides: { ...params.model ? { model: params.model } : {} }
+    });
+    const permissionMode = params.dangerouslySkipPermissions ? "dangerous" : params.mode;
+    const harnessName = params.harness ?? config.agent.default;
+    const sandboxMode = params.sandbox ?? config.agent.sandbox;
+    let selection;
+    try {
+      selection = (await resolveRunSandbox(harnessName, sandboxMode, config)).selection;
+    } catch (err) {
+      throw new JSONRPCErrorException(
+        err instanceof Error ? err.message : String(err),
+        INVALID_PARAMS
+      );
+    }
+    try {
+      let resolved;
+      try {
+        resolved = resolveInvestigation(
+          {
+            ...params.alert ? { alert: params.alert } : {},
+            ...params.query ? { query: params.query } : {},
+            ...params.repo ? { repo: params.repo } : {},
+            ...params.harness ? { harness: params.harness } : {},
+            ...params.service ? { service: params.service } : {},
+            ...permissionMode ? { permissionMode } : {},
+            ...selection ? {
+              sandbox: selection.sandbox,
+              requestedSandbox: selection.requested
+            } : {},
+            ...params.maxTurns ? { maxTurns: params.maxTurns } : {}
+          },
+          config
+        );
+      } catch (err) {
+        throw new JSONRPCErrorException(
+          err instanceof Error ? err.message : String(err),
+          INVALID_PARAMS
+        );
+      }
+      const { context, harness, synth, harnessName: harnessName2, fidelity, maxBranches } = resolved;
+      const primaryAlert = context.alerts[0];
+      const runId = randomUUID();
+      const repoSlug = await resolveRepoSlug(config.repo, cwd);
+      const sessions = createSessionManager(config.workspace.dir);
+      const fileSession = createFileSessionStore(sessions, {
+        runId,
+        alertname: primaryAlert.alertname,
+        agent: harnessName2,
+        ...repoSlug ? { repo: repoSlug } : {}
+      });
+      const outcome = await conductRun(
+        {
+          context,
+          harness,
+          synth,
+          fidelity,
+          runId,
+          ...maxBranches !== void 0 ? { maxBranches } : {}
+        },
+        {
+          sink: (event) => {
+            notify("investigate/event", { runId, event });
+          },
+          store: fileSession.store
         }
-        catch (err) {
-            consola.error(err instanceof Error ? err.message : String(err));
-            process.exit(1);
+      );
+      if (!outcome.report) {
+        throw new JSONRPCErrorException(
+          outcome.error ?? "investigation produced no evidence",
+          outcome.failureKind === "no-evidence" ? NO_EVIDENCE : INTERNAL_ERROR,
+          { runId }
+        );
+      }
+      return { runId: outcome.runId, report: outcome.report };
+    } finally {
+      if (selection) await selection.sandbox.destroy();
+    }
+  };
+  const server = new JSONRPCServer();
+  server.addMethod("initialize", () => handleInitialize());
+  server.addMethod(
+    "investigate",
+    (params) => handleInvestigate(params)
+  );
+  server.mapErrorToJSONRPCErrorResponse = (id, error) => {
+    if (error instanceof JSONRPCErrorException) {
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: {
+          code: error.code,
+          message: error.message,
+          ...error.data !== void 0 ? { data: error.data } : {}
         }
-    },
+      };
+    }
+    return {
+      jsonrpc: "2.0",
+      id,
+      error: {
+        code: INTERNAL_ERROR,
+        message: error instanceof Error ? error.message : String(error)
+      }
+    };
+  };
+  const handleLine = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      write({
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: PARSE_ERROR, message: "Parse error: invalid JSON" }
+      });
+      return;
+    }
+    void server.receive(parsed).then((response) => {
+      if (response) write(response);
+    });
+  };
+  const rl = createInterface({ input, crlfDelay: Number.POSITIVE_INFINITY });
+  rl.on("line", handleLine);
+  await new Promise((resolveClose) => {
+    rl.on("close", () => resolveClose());
+  });
+}
+
+// src/cli/serve.ts
+var SERVER_VERSION = cliVersion();
+var serve_default = defineCommand({
+  meta: {
+    name: "serve",
+    description: "Run the JSON-RPC 2.0 server over stdio (the LIVE channel for the desktop app / API).\n\nExamples:\n  $ pl serve"
+  },
+  async run({ args, cmd }) {
+    try {
+      assertKnownFlags(args, cmd);
+      await runJsonRpcServer({ version: SERVER_VERSION });
+    } catch (err) {
+      consola.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  }
 });
-//# sourceMappingURL=serve.js.map
+export {
+  serve_default as default
+};

package/dist/src/cli/status.js

@@ -1,93 +1,94 @@
-// SPDX-License-Identifier: Apache-2.0
-// Copyright 2026 Sumit Patel
+import {
+  createSessionManager
+} from "../../chunk-CTKCK7QT.js";
+import {
+  assertKnownFlags
+} from "../../chunk-PTBCAI34.js";
+import "../../chunk-6N4PHBII.js";
+import "../../chunk-2Z7QZSIS.js";
+
+// src/cli/status.ts
 import { defineCommand } from "citty";
 import consola from "consola";
-import { createSessionManager } from "../core/session.js";
-import { assertKnownFlags } from "./flags.js";
-export default defineCommand({
-    meta: {
-        name: "status",
-        description: "List incident groups and runs with their state (running, done, errored, suppressed)\n\nExamples:\n  $ pl status\n  $ pl status --status running,errored\n  $ pl status --json",
+var status_default = defineCommand({
+  meta: {
+    name: "status",
+    description: "List incident groups and runs with their state (running, done, errored, suppressed)\n\nExamples:\n  $ pl status\n  $ pl status --status running,errored\n  $ pl status --json"
+  },
+  args: {
+    status: {
+      type: "string",
+      description: "Filter by status (running, done, errored, suppressed)",
+      required: false
     },
-    args: {
-        status: {
-            type: "string",
-            description: "Filter by status (running, done, errored, suppressed)",
-            required: false,
-        },
-        "workspace-dir": {
-            type: "string",
-            description: "Workspace directory (default: ~/.prismalens; overridden by PRISMALENS_WORKSPACE_DIR)",
-            required: false,
-        },
-        json: {
-            type: "boolean",
-            description: "Print machine-readable JSON",
-            required: false,
-        },
+    "workspace-dir": {
+      type: "string",
+      description: "Workspace directory (default: ~/.prismalens; overridden by PRISMALENS_WORKSPACE_DIR)",
+      required: false
     },
-    async run({ args, cmd }) {
-        let sessions;
-        try {
-            assertKnownFlags(args, cmd);
-            sessions = createSessionManager(args["workspace-dir"]);
-            const valid = [
-                "running",
-                "done",
-                "errored",
-                "suppressed",
-            ];
-            let filter;
-            if (args.status) {
-                const parts = args.status
-                    .split(",")
-                    .map((s) => s.trim())
-                    .filter((s) => s.length > 0);
-                const bad = parts.filter((s) => !valid.includes(s));
-                if (bad.length > 0) {
-                    consola.error(`Invalid status: ${bad.join(", ")}. Valid: ${valid.join(", ")}`);
-                    // exitCode (not process.exit) so the finally block still closes the
-                    // session manager before the process tears down.
-                    process.exitCode = 1;
-                    return;
-                }
-                filter = { status: parts };
-            }
-            const json = Boolean(args.json);
-            const runs = await sessions.list(filter);
-            if (json) {
-                process.stdout.write(`${JSON.stringify(runs, null, 2)}\n`);
-                return;
-            }
-            if (runs.length === 0) {
-                consola.info("No runs found.");
-                return;
-            }
-            for (const run of runs) {
-                const info = [
-                    `run_id: ${run.runId}`,
-                    `status: ${run.status}`,
-                    `created_at: ${run.createdAt}`,
-                ];
-                if (run.alertname)
-                    info.push(`alertname: ${run.alertname}`);
-                if (run.agent)
-                    info.push(`agent: ${run.agent}`);
-                if (run.repo)
-                    info.push(`repo: ${run.repo}`);
-                if (run.status === "suppressed" && run.suppressionReason) {
-                    info.push(`suppressed_by: ${run.suppressionReason}`);
-                }
-                consola.log(info.join(" | "));
-            }
+    json: {
+      type: "boolean",
+      description: "Print machine-readable JSON",
+      required: false
+    }
+  },
+  async run({ args, cmd }) {
+    let sessions;
+    try {
+      assertKnownFlags(args, cmd);
+      sessions = createSessionManager(args["workspace-dir"]);
+      const valid = [
+        "running",
+        "done",
+        "errored",
+        "suppressed"
+      ];
+      let filter;
+      if (args.status) {
+        const parts = args.status.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+        const bad = parts.filter((s) => !valid.includes(s));
+        if (bad.length > 0) {
+          consola.error(
+            `Invalid status: ${bad.join(", ")}. Valid: ${valid.join(", ")}`
+          );
+          process.exitCode = 1;
+          return;
         }
-        catch (err) {
-            consola.error("Failed to read status:", err);
-            process.exitCode = 1;
+        filter = { status: parts };
+      }
+      const json = Boolean(args.json);
+      const runs = await sessions.list(filter);
+      if (json) {
+        process.stdout.write(`${JSON.stringify(runs, null, 2)}
+`);
+        return;
+      }
+      if (runs.length === 0) {
+        consola.info("No runs found.");
+        return;
+      }
+      for (const run of runs) {
+        const info = [
+          `run_id: ${run.runId}`,
+          `status: ${run.status}`,
+          `created_at: ${run.createdAt}`
+        ];
+        if (run.alertname) info.push(`alertname: ${run.alertname}`);
+        if (run.agent) info.push(`agent: ${run.agent}`);
+        if (run.repo) info.push(`repo: ${run.repo}`);
+        if (run.status === "suppressed" && run.suppressionReason) {
+          info.push(`suppressed_by: ${run.suppressionReason}`);
         }
-        finally {
-            sessions?.close?.();
-        }
-    },
+        consola.log(info.join(" | "));
+      }
+    } catch (err) {
+      consola.error("Failed to read status:", err);
+      process.exitCode = 1;
+    } finally {
+      sessions?.close?.();
+    }
+  }
 });
-//# sourceMappingURL=status.js.map
+export {
+  status_default as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prismalens",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "AI root-cause investigation from your terminal — point it at a repo, pipe it an alert, get an evidence-linked report",
   "license": "Apache-2.0",
   "type": "module",
@@ -36,25 +36,34 @@
     "access": "public"
   },
   "dependencies": {
+    "@ai-sdk/anthropic": "^4.0.7",
+    "@ai-sdk/google": "^4.0.8",
+    "@ai-sdk/groq": "^4.0.5",
+    "@ai-sdk/openai": "^4.0.7",
+    "@ai-sdk/openai-compatible": "^3.0.5",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.199",
+    "@orpc/contract": "^1.14.6",
+    "ai": "^7.0.14",
     "citty": "^0.2.2",
     "consola": "^3.4.2",
     "env-paths": "^4.0.0",
     "json-rpc-2.0": "^1.7.1",
     "yaml": "^2.9.0",
-    "zod": "^3.25.76",
-    "@prismalens/contracts": "0.1.1",
-    "@prismalens/engine": "0.2.1",
-    "@prismalens/config": "0.3.0"
+    "zod": "^3.25.76"
   },
   "devDependencies": {
     "@types/node": "^24.13.2",
     "@vitest/coverage-v8": "^4.1.9",
+    "tsup": "^8.5.1",
     "tsx": "^4.22.5",
     "typescript": "^5.9.3",
-    "vitest": "^4.1.9"
+    "vitest": "^4.1.9",
+    "@prismalens/config": "0.3.0",
+    "@prismalens/contracts": "0.1.1",
+    "@prismalens/engine": "0.2.1"
   },
   "scripts": {
-    "build": "tsc",
+    "build": "tsup",
     "typecheck": "tsc --noEmit",
     "dev": "tsx bin/prismalens.ts",
     "test": "vitest run --coverage"

package/dist/bin/prismalens.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=prismalens.d.ts.map

package/dist/bin/prismalens.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prismalens.d.ts","sourceRoot":"","sources":["../../bin/prismalens.ts"],"names":[],"mappings":""}