@mhingston5/jev-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mark Hingston
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,137 @@
+# Jev CLI
+
+A small, provider-agnostic command-line interface and Node.js client for [TypeSafe AI Jev](https://typesafe.ai/).
+
+The package owns the reusable Jev boundary: provider selection, System One transport, typed question construction, and the `jev` executable. Domain-specific tools such as `jev-agent-browser` can depend on this package while keeping their own observation, policy, and execution loops.
+
+## Install
+
+```bash
+npm install -g @mhingston5/jev-cli
+```
+
+Node.js 20 or newer is required.
+
+```bash
+export TYPESAFE_API_KEY="..."
+jev noul \
+  --state "Please refund this today" \
+  --question "Does the message communicate urgency?"
+```
+
+The CLI never accepts API keys as command-line arguments. Supply credentials through environment variables or your secret manager.
+
+## Commands
+
+### Noul
+
+```bash
+jev noul \
+  --state '{"ticket":"Please fix this ASAP"}' \
+  --question "Does this communicate urgency?" \
+  --answer-only
+```
+
+### Choice
+
+```bash
+jev choice \
+  --state '{"ticket":"I was charged twice"}' \
+  --question "Which team should handle this?" \
+  --choices '{"billing":"Payments and refunds","technical":"Bugs and outages","other":"Anything else"}'
+```
+
+### Score
+
+```bash
+jev score \
+  --state "The service is unusable and blocking production" \
+  --question "How severe is this?" \
+  --levels '["minor","degraded","blocking"]'
+```
+
+### Batch
+
+```bash
+cat ticket.json | jev run --questions '{
+  "urgent": {
+    "type": "noul",
+    "instructions": "Does the ticket communicate urgency?"
+  },
+  "queue": {
+    "type": "choice",
+    "instructions": "Which team should handle this?",
+    "choices": {
+      "billing": "Payments and refunds",
+      "technical": "Bugs and outages"
+    }
+  },
+  "severity": {
+    "type": "score",
+    "instructions": "How severe is the impact?",
+    "levels": ["minor", "degraded", "blocking"]
+  }
+}'
+```
+
+Use `--questions-file questions.json` for checked-in question definitions. State can be supplied using `--state`, `--state-file`, or stdin.
+
+## Providers
+
+| Provider | CLI value | Credentials | Default model |
+| --- | --- | --- | --- |
+| TypeSafe | `typesafe` | `TYPESAFE_API_KEY` | `jev-1.13.0` |
+| Vercel AI Gateway | `vercel` | `AI_GATEWAY_API_KEY` | `typesafe-ai/jev` |
+| Cloudflare AI | `cloudflare` | `CLOUDFLARE_API_TOKEN`, `CLOUDFLARE_ACCOUNT_ID` | `typesafe/jev` |
+| Custom | `custom` | `JEV_API_KEY` when required | caller-defined / Jev default |
+
+Select the transport with `--provider` or `JEV_PROVIDER`. Override the model with `--model` or `JEV_MODEL`, and the endpoint with `--endpoint` or `JEV_ENDPOINT`.
+
+```bash
+jev doctor --provider vercel
+```
+
+`doctor` reports provider/model configuration and whether expected credential environment variables are present. It never prints credential values.
+
+## Library API
+
+```ts
+import { createJevClient, choice, noul, score } from "@mhingston5/jev-cli";
+
+const client = createJevClient({ provider: "typesafe" });
+
+const response = await client.systemOne({
+  state: { ticket: "I was charged twice and need one charge refunded today." },
+  questions: {
+    intent: choice("What is the customer's main request?", {
+      refund: "The customer wants money returned.",
+      technical: "The customer needs technical help.",
+    }),
+    urgent: noul("Does the ticket explicitly communicate time pressure?"),
+    severity: score("How severe is the impact?", ["minor", "degraded", "blocking"]),
+  },
+});
+
+console.log(response.answers);
+```
+
+For dynamically constructed question definitions, `buildQuestion()` and `buildQuestions()` accept JSON-friendly specs. The package also exports `SystemOneLikeClient` so higher-level libraries can inject deterministic fixture clients in tests.
+
+
+## Development
+
+```bash
+npm install
+npm run typecheck
+npm test
+npm run build
+npm run pack:check
+```
+
+## Publishing
+
+The `publish` workflow publishes `@mhingston5/jev-cli` on a `v*` tag or manual workflow dispatch. The first npm publication requires an `NPM_TOKEN` repository secret with permission to publish the package. After the package exists, the workflow can move to npm trusted publishing.
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { JEV_PROVIDERS, createJevClient, credentialEnvironmentForProvider, defaultModelForProvider, resolveJevProvider, } from "./client.js";
+import { buildQuestions } from "./questions.js";
+function usage(exitCode = 0) {
+    const text = `Usage:
+  jev noul   --question <text> [state options] [provider options]
+  jev choice --question <text> --choices <json> [state options] [provider options]
+  jev score  --question <text> --levels <json> [state options] [provider options]
+  jev run    (--questions <json> | --questions-file <path>) [state options] [provider options]
+  jev doctor [provider options]
+
+State options:
+  --state <text|json>          State inline. JSON is parsed when valid.
+  --state-file <path>         Read state from a file. JSON is parsed when valid.
+                              If omitted, state is read from stdin.
+
+Question options:
+  --true-label <text>         Optional Noul true criterion.
+  --false-label <text>        Optional Noul false criterion.
+  --choices <json>            Choice map.
+  --levels <json>             Ordered Score levels.
+  --questions <json>          Batch question specs keyed by output id.
+  --questions-file <path>     Read batch question specs from JSON.
+
+Provider options:
+  --provider <typesafe|vercel|cloudflare|custom>
+  --model <id>
+  --endpoint <url>
+  --account-id <id>           Cloudflare account id; env is preferred.
+
+Output options:
+  --answer-only               Print only the answer for single-question commands.
+  --compact                   Emit compact JSON.
+
+Credentials are read from environment variables, not command-line flags.`;
+    (exitCode === 0 ? console.log : console.error)(text);
+    process.exit(exitCode);
+}
+function parseFlags(args) {
+    const flags = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        if (!token.startsWith("--"))
+            throw new Error(`unexpected positional argument: ${token}`);
+        const next = args[index + 1];
+        if (next != null && !next.startsWith("--")) {
+            const values = flags.get(token) ?? [];
+            values.push(next);
+            flags.set(token, values);
+            index += 1;
+        }
+        else {
+            flags.set(token, []);
+        }
+    }
+    return flags;
+}
+function hasFlag(flags, name) {
+    return flags.has(name);
+}
+function flagValue(flags, name) {
+    const values = flags.get(name);
+    return values?.[values.length - 1];
+}
+function requiredFlag(flags, name) {
+    const value = flagValue(flags, name);
+    if (value == null)
+        throw new Error(`${name} is required`);
+    return value;
+}
+function parseMaybeJson(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return "";
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return text;
+    }
+}
+async function readStdin() {
+    let input = "";
+    for await (const chunk of process.stdin)
+        input += chunk;
+    return input;
+}
+async function readState(flags) {
+    const inline = flagValue(flags, "--state");
+    const file = flagValue(flags, "--state-file");
+    if (inline != null && file != null)
+        throw new Error("use --state or --state-file, not both");
+    if (inline != null)
+        return parseMaybeJson(inline);
+    if (file != null)
+        return parseMaybeJson(await readFile(file, "utf8"));
+    if (process.stdin.isTTY)
+        throw new Error("state is required via --state, --state-file, or stdin");
+    const stdin = await readStdin();
+    if (!stdin.trim())
+        throw new Error("stdin did not contain state");
+    return parseMaybeJson(stdin);
+}
+function parseJson(text, label) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new Error(`${label} must be valid JSON`);
+    }
+}
+async function readQuestions(flags) {
+    const inline = flagValue(flags, "--questions");
+    const file = flagValue(flags, "--questions-file");
+    if ((inline == null) === (file == null)) {
+        throw new Error("provide exactly one of --questions or --questions-file");
+    }
+    const text = inline ?? await readFile(file, "utf8");
+    const value = parseJson(text, "questions");
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("questions must be a JSON object keyed by question id");
+    }
+    return value;
+}
+function clientOptions(flags) {
+    const providerText = flagValue(flags, "--provider");
+    if (providerText != null && !JEV_PROVIDERS.includes(providerText)) {
+        throw new Error(`--provider must be one of ${JEV_PROVIDERS.join(", ")}`);
+    }
+    return {
+        provider: providerText,
+        model: flagValue(flags, "--model"),
+        endpoint: flagValue(flags, "--endpoint"),
+        accountId: flagValue(flags, "--account-id"),
+    };
+}
+function output(value, compact) {
+    console.log(JSON.stringify(value, null, compact ? 0 : 2));
+}
+async function runQuestion(state, specs, flags, answerOnly) {
+    const options = clientOptions(flags);
+    const provider = resolveJevProvider(options);
+    const model = options.model ?? defaultModelForProvider(provider);
+    const client = createJevClient(options);
+    const response = await client.systemOne({ model, state, questions: buildQuestions(specs) });
+    if (answerOnly && Object.keys(specs).length === 1) {
+        const key = Object.keys(specs)[0];
+        output(response.answers[key], hasFlag(flags, "--compact"));
+        return;
+    }
+    output(response, hasFlag(flags, "--compact"));
+}
+async function main() {
+    const [command, ...rest] = process.argv.slice(2);
+    if (!command || command === "--help" || command === "-h" || command === "help")
+        usage(0);
+    const flags = parseFlags(rest);
+    if (command === "doctor") {
+        const options = clientOptions(flags);
+        const provider = resolveJevProvider(options);
+        const credentialEnvironment = credentialEnvironmentForProvider(provider);
+        output({
+            provider,
+            model: options.model ?? defaultModelForProvider(provider),
+            credentials: Object.fromEntries(credentialEnvironment.map((name) => [name, Boolean(process.env[name])])),
+            endpointOverride: Boolean(options.endpoint ?? process.env.JEV_ENDPOINT),
+        }, hasFlag(flags, "--compact"));
+        return;
+    }
+    const state = await readState(flags);
+    if (command === "noul") {
+        await runQuestion(state, {
+            result: {
+                type: "noul",
+                instructions: requiredFlag(flags, "--question"),
+                ...(flagValue(flags, "--true-label") != null || flagValue(flags, "--false-label") != null
+                    ? { labels: { true: flagValue(flags, "--true-label"), false: flagValue(flags, "--false-label") } }
+                    : {}),
+            },
+        }, flags, hasFlag(flags, "--answer-only"));
+        return;
+    }
+    if (command === "choice") {
+        const choices = parseJson(requiredFlag(flags, "--choices"), "--choices");
+        if (!choices || typeof choices !== "object" || Array.isArray(choices)) {
+            throw new Error("--choices must be a JSON object");
+        }
+        await runQuestion(state, {
+            result: {
+                type: "choice",
+                instructions: requiredFlag(flags, "--question"),
+                choices: choices,
+            },
+        }, flags, hasFlag(flags, "--answer-only"));
+        return;
+    }
+    if (command === "score") {
+        const levels = parseJson(requiredFlag(flags, "--levels"), "--levels");
+        if (!Array.isArray(levels) || levels.some((item) => typeof item !== "string")) {
+            throw new Error("--levels must be a JSON array of strings");
+        }
+        await runQuestion(state, {
+            result: {
+                type: "score",
+                instructions: requiredFlag(flags, "--question"),
+                levels: levels,
+            },
+        }, flags, hasFlag(flags, "--answer-only"));
+        return;
+    }
+    if (command === "run") {
+        await runQuestion(state, await readQuestions(flags), flags, false);
+        return;
+    }
+    throw new Error(`unknown command: ${command}`);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`jev: ${message}`);
+    process.exitCode = 1;
+});

package/dist/client.js

@@ -0,0 +1,210 @@
+import { TypeSafeClient } from "@typesafe-ai/sdk";
+export const JEV_PROVIDERS = ["typesafe", "vercel", "cloudflare", "custom"];
+export const DEFAULT_ENDPOINT = "https://api.typesafe.ai/v1/systemone";
+export const VERCEL_ENDPOINT = "https://ai-gateway.vercel.sh/typesafe/v1/systemone";
+function endpointRoot(endpoint) {
+    const url = new URL(endpoint);
+    return `${url.origin}${url.pathname.replace(/\/v1\/systemone\/?$/, "")}`.replace(/\/$/, "");
+}
+function responsePayload(payload) {
+    const body = payload?.data ?? payload;
+    const value = body?.answers ? body : body?.result?.answers ? body.result : body?.output?.answers ? body.output : body;
+    if (!value || typeof value !== "object" || !value.answers || typeof value.answers !== "object") {
+        throw new Error("Jev API response did not contain answers");
+    }
+    return {
+        model: typeof value.model === "string" ? value.model : "jev",
+        answers: value.answers,
+        usage: value.usage,
+    };
+}
+function errorMessage(body) {
+    return body?.error?.message ?? body?.errors?.[0]?.message ?? body?.message ?? "request failed";
+}
+export function resolveJevProvider(options = {}) {
+    if (options.provider)
+        return options.provider;
+    const env = process.env.JEV_PROVIDER?.trim().toLowerCase();
+    if (env && JEV_PROVIDERS.includes(env))
+        return env;
+    return "typesafe";
+}
+export function defaultModelForProvider(provider) {
+    const override = process.env.JEV_MODEL?.trim();
+    if (override)
+        return override;
+    switch (provider) {
+        case "typesafe":
+            return process.env.TYPESAFE_DEFAULT_MODEL?.trim() || "jev-1.13.0";
+        case "vercel":
+            return "typesafe-ai/jev";
+        case "cloudflare":
+            return "typesafe/jev";
+        case "custom":
+            return process.env.TYPESAFE_DEFAULT_MODEL?.trim() || "jev-1.13.0";
+    }
+}
+export function credentialEnvironmentForProvider(provider) {
+    switch (provider) {
+        case "typesafe": return ["TYPESAFE_API_KEY"];
+        case "vercel": return ["AI_GATEWAY_API_KEY"];
+        case "cloudflare": return ["CLOUDFLARE_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"];
+        case "custom": return ["JEV_API_KEY"];
+    }
+}
+function defaultApiKey(provider) {
+    switch (provider) {
+        case "typesafe": return process.env.TYPESAFE_API_KEY;
+        case "vercel": return process.env.AI_GATEWAY_API_KEY;
+        case "cloudflare": return process.env.CLOUDFLARE_API_TOKEN;
+        case "custom": return process.env.JEV_API_KEY ?? process.env.TYPESAFE_API_KEY;
+    }
+}
+export function defaultEndpointForProvider(provider, accountId) {
+    const override = process.env.JEV_ENDPOINT?.trim();
+    if (override)
+        return override;
+    switch (provider) {
+        case "typesafe":
+            return process.env.TYPESAFE_BASE_URL?.trim() || DEFAULT_ENDPOINT;
+        case "vercel":
+            return VERCEL_ENDPOINT;
+        case "cloudflare": {
+            const id = accountId ?? process.env.CLOUDFLARE_ACCOUNT_ID?.trim();
+            if (!id)
+                throw new Error("CLOUDFLARE_ACCOUNT_ID is required for the cloudflare provider unless --endpoint is supplied");
+            return `https://api.cloudflare.com/client/v4/accounts/${id}/ai/run`;
+        }
+        case "custom":
+            return DEFAULT_ENDPOINT;
+    }
+}
+class TypeSafeCompatibleJevClient {
+    client;
+    model;
+    constructor(provider, options = {}) {
+        const apiKey = options.apiKey ?? defaultApiKey(provider);
+        if (!apiKey) {
+            throw new Error(provider === "vercel"
+                ? "AI_GATEWAY_API_KEY is required for the vercel provider"
+                : "TYPESAFE_API_KEY is required for the typesafe provider");
+        }
+        const endpoint = options.endpoint ?? defaultEndpointForProvider(provider, options.accountId);
+        this.model = options.model ?? defaultModelForProvider(provider);
+        this.client = new TypeSafeClient({
+            apiKey,
+            baseURL: endpointRoot(endpoint),
+            defaultModel: this.model,
+            timeout: options.timeoutMs,
+            defaultHeaders: options.headers,
+            ...(options.fetchImpl ? { fetch: options.fetchImpl } : {}),
+        });
+    }
+    async systemOne(request) {
+        return this.client.systemOne({ ...request, model: this.model });
+    }
+}
+export class FetchJevClient {
+    endpoint;
+    apiKey;
+    model;
+    timeoutMs;
+    headers;
+    fetchImpl;
+    constructor(options = {}) {
+        this.endpoint = options.endpoint ?? DEFAULT_ENDPOINT;
+        this.apiKey = options.apiKey ?? defaultApiKey("custom");
+        this.model = options.model;
+        this.timeoutMs = options.timeoutMs ?? 30_000;
+        this.headers = { "content-type": "application/json", ...(options.headers ?? {}) };
+        this.fetchImpl = options.fetchImpl ?? fetch;
+    }
+    async systemOne(request) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await this.fetchImpl(this.endpoint, {
+                method: "POST",
+                headers: {
+                    ...this.headers,
+                    ...(this.apiKey ? { authorization: `Bearer ${this.apiKey}` } : {}),
+                },
+                body: JSON.stringify({ ...request, ...(this.model ? { model: this.model } : {}) }),
+                signal: controller.signal,
+            });
+            const body = await response.json().catch(() => undefined);
+            if (!response.ok)
+                throw new Error(`Jev API ${response.status}: ${errorMessage(body)}`);
+            return responsePayload(body);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new Error(`Jev API timed out after ${this.timeoutMs}ms`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+export class CloudflareJevClient {
+    endpoint;
+    apiKey;
+    model;
+    timeoutMs;
+    headers;
+    fetchImpl;
+    constructor(options = {}) {
+        this.endpoint = options.endpoint ?? defaultEndpointForProvider("cloudflare", options.accountId);
+        const apiKey = options.apiKey ?? defaultApiKey("cloudflare");
+        if (!apiKey)
+            throw new Error("CLOUDFLARE_API_TOKEN is required for the cloudflare provider");
+        this.apiKey = apiKey;
+        this.model = options.model ?? defaultModelForProvider("cloudflare");
+        this.timeoutMs = options.timeoutMs ?? 30_000;
+        this.headers = { "content-type": "application/json", ...(options.headers ?? {}) };
+        this.fetchImpl = options.fetchImpl ?? fetch;
+    }
+    async systemOne(request) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await this.fetchImpl(this.endpoint, {
+                method: "POST",
+                headers: { ...this.headers, authorization: `Bearer ${this.apiKey}` },
+                body: JSON.stringify({
+                    model: this.model,
+                    input: { state: request.state, questions: request.questions },
+                }),
+                signal: controller.signal,
+            });
+            const body = await response.json().catch(() => undefined);
+            if (!response.ok)
+                throw new Error(`Jev API ${response.status}: ${errorMessage(body)}`);
+            return responsePayload(body);
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new Error(`Jev API timed out after ${this.timeoutMs}ms`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+export function createJevClient(options = {}) {
+    const provider = resolveJevProvider(options);
+    if (provider === "cloudflare")
+        return new CloudflareJevClient(options);
+    if (provider === "custom") {
+        return new FetchJevClient({
+            ...options,
+            endpoint: options.endpoint ?? process.env.JEV_ENDPOINT ?? DEFAULT_ENDPOINT,
+            model: options.model ?? process.env.JEV_MODEL,
+        });
+    }
+    return new TypeSafeCompatibleJevClient(provider, options);
+}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./client.js";
+export * from "./questions.js";
+export { choice, noul, score, TypeSafeClient } from "@typesafe-ai/sdk";

package/dist/questions.js

@@ -0,0 +1,45 @@
+import { choice, noul, score } from "@typesafe-ai/sdk";
+function requireInstructions(instructions) {
+    if (!instructions.trim())
+        throw new Error("question instructions must not be empty");
+}
+export function buildQuestion(spec) {
+    requireInstructions(spec.instructions);
+    if (spec.type === "noul") {
+        if (!spec.labels)
+            return noul(spec.instructions);
+        return noul(spec.instructions, {
+            true: spec.labels.true ?? "The condition is true.",
+            false: spec.labels.false ?? "The condition is false.",
+        });
+    }
+    if (spec.type === "choice") {
+        const entries = Object.entries(spec.choices);
+        if (entries.length < 2)
+            throw new Error("choice questions require at least two choices");
+        if (entries.length > 255)
+            throw new Error("choice questions support at most 255 choices");
+        if (entries.some(([id]) => !id.trim()))
+            throw new Error("choice ids must not be empty");
+        return choice(spec.instructions, spec.choices);
+    }
+    if (spec.levels.length < 2)
+        throw new Error("score questions require at least two levels");
+    if (spec.levels.length > 10)
+        throw new Error("score questions support at most ten levels");
+    if (spec.levels.some((level) => !level.trim()))
+        throw new Error("score levels must not be empty");
+    return score(spec.instructions, spec.levels);
+}
+export function buildQuestions(specs) {
+    const entries = Object.entries(specs);
+    if (!entries.length)
+        throw new Error("at least one question is required");
+    const result = {};
+    for (const [id, spec] of entries) {
+        if (!id.trim())
+            throw new Error("question ids must not be empty");
+        result[id] = buildQuestion(spec);
+    }
+    return result;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@mhingston5/jev-cli",
+  "version": "0.1.0",
+  "description": "Provider-agnostic CLI and client for TypeSafe AI Jev",
+  "license": "MIT",
+  "author": "Mark Hingston",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mhingston/jev-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mhingston/jev-cli/issues"
+  },
+  "homepage": "https://github.com/mhingston/jev-cli#readme",
+  "keywords": [
+    "jev",
+    "typesafe",
+    "system-one",
+    "typed-decisions",
+    "cli"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "jev": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build",
+    "pack:check": "npm pack --dry-run",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@typesafe-ai/sdk": "^0.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^5.0.1"
+  }
+}