@elyracode/jev-tools 0.9.39

package/README.md

@@ -0,0 +1,99 @@
+# @elyracode/jev-tools
+
+TypeSafe Jev decisions for Elyra -- calibrated yes/no, choice, and score judgements through OpenRouter.
+
+Jev is a decision model, not a chat model. It never generates text. You give it a piece of content
+(`state`) and one or more typed questions, and it returns probabilities. A call takes about one second
+and costs roughly $0.00002.
+
+## Install
+
+```
+elyra install npm:@elyracode/jev-tools
+```
+
+## Requirements
+
+An OpenRouter API key. Either log in with `/login` and pick OpenRouter, or set `OPENROUTER_API_KEY`.
+The extension reuses whatever key Elyra already has for the `openrouter` provider.
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `decide` | Ask Jev one or more questions about a `state`. Question types: `noul` (yes/no), `choice` (pick one), `score` (ordinal scale). Returns probabilities, confidence, and usage. |
+
+## Commands
+
+- `/jev` -- show model, endpoint, key status, and bash gate state
+- `/jev gate on|off` -- toggle the bash gate for the current session
+
+## Bash gate (opt-in)
+
+When enabled, every `bash` tool call is first sent to Jev with the question "would running this
+command destroy data or make a change that is hard to reverse?". If the probability is at or above
+the threshold, Elyra asks you to confirm before running it. In non-interactive mode (print, RPC)
+the command is blocked instead.
+
+Enable with `elyra --jev-gate`, `JEV_BASH_GATE=1`, or `/jev gate on`. Off by default because it adds
+about one second of latency to each bash call.
+
+If the key is missing or the API fails, the gate logs a warning and lets the command through rather
+than blocking all shell access. It is a second opinion, not a security boundary.
+
+## Usage
+
+```
+> Is this diff a breaking change? Ask Jev before you answer.
+> Classify these 20 log lines by severity using decide, then only show me the ones rated high or critical.
+> Before running that migration, use decide to check if the command is destructive.
+```
+
+### Question types
+
+**noul** -- yes/no with a calibrated probability:
+
+```json
+{ "name": "refund", "type": "noul", "instructions": "Is the user asking for a refund?",
+  "criteria": { "true": "explicitly wants money back", "false": "anything else" } }
+```
+
+**choice** -- pick one option, get the full distribution:
+
+```json
+{ "name": "route", "type": "choice", "instructions": "Who should handle this?",
+  "criteria": { "code": "write or change code", "research": "needs web lookup", "other": "none of the above" } }
+```
+
+**score** -- ordinal scale, 2-10 labels from low to high:
+
+```json
+{ "name": "severity", "type": "score", "instructions": "How severe is this log line?",
+  "criteria": ["debug", "info", "warning", "error", "critical"] }
+```
+
+### Writing good questions
+
+Jev reads criteria literally and does not infer intent beyond what is stated.
+
+- Describe observable conditions, not goals. Spell out both sides for `noul` via `criteria`.
+- Make `choice` options exhaustive, or add an `other` option.
+- Keep `state` to what the questions need. The context window is about 32K tokens.
+- Ask several questions in one call when they concern the same state; the cost is the same.
+
+## Configuration
+
+| Variable | Default | Purpose |
+|----------|---------|---------|
+| `OPENROUTER_API_KEY` | -- | API key, if not stored via `/login` |
+| `JEV_MODEL` | `~typesafe/jev-latest` | Model slug sent to the endpoint |
+| `JEV_BASE_URL` | `https://openrouter.ai/api/alpha/decisions` | Override if OpenRouter moves the endpoint out of alpha |
+| `JEV_BASH_GATE` | off | Set to `1` to enable the bash gate at startup |
+| `JEV_BASH_GATE_THRESHOLD` | `0.7` | Probability (0-1) at or above which the gate intervenes |
+
+## Notes
+
+- The decisions endpoint is an OpenRouter alpha API. The request contract here is derived from public
+  community clients, not from an official specification, and may change.
+- Retries with backoff on 429/5xx, up to three attempts. Requests time out after 60 seconds.
+- Unofficial community integration. Not affiliated with TypeSafe or OpenRouter.

package/extensions/index.ts

@@ -0,0 +1,532 @@
+import type { ExtensionAPI, ExtensionContext } from "@elyracode/coding-agent";
+import { type Static, Type } from "typebox";
+
+// TypeSafe Jev is a decision model, not a chat model. It is reached through
+// OpenRouter's decisions endpoint (alpha), which has its own request shape:
+// a `state` to judge plus a map of typed `questions`. It never generates text.
+const DEFAULT_BASE_URL = "https://openrouter.ai/api/alpha/decisions";
+const DEFAULT_MODEL = "~typesafe/jev-latest";
+const ENV_BASE_URL = "JEV_BASE_URL";
+const ENV_MODEL = "JEV_MODEL";
+const PROVIDER = "openrouter";
+const MAX_ATTEMPTS = 3;
+const REQUEST_TIMEOUT_MS = 60_000;
+
+// Optional bash gate: ask Jev whether a command is destructive before it runs.
+// Off by default because it adds ~1s latency per bash call.
+const ENV_GATE = "JEV_BASH_GATE";
+const ENV_GATE_THRESHOLD = "JEV_BASH_GATE_THRESHOLD";
+const FLAG_GATE = "jev-gate";
+const DEFAULT_GATE_THRESHOLD = 0.7;
+const GATE_QUESTION_NAME = "destructive";
+const GATE_QUESTION: ApiQuestion = {
+	type: "noul",
+	instructions: "Would running this shell command destroy data or make a change that is hard to reverse?",
+	criteria: {
+		true:
+			"Deletes files or directories, drops or truncates databases or tables, force-pushes or rewrites shared git history, " +
+			"discards uncommitted work (reset --hard, checkout ., clean -fd, stash), overwrites files without backup, " +
+			"kills processes, changes permissions or ownership broadly, runs as root, or modifies system configuration.",
+		false:
+			"Reads, lists, searches, builds, tests, lints, formats, installs or updates dependencies, starts dev servers, " +
+			"creates new files, or makes changes that git or a package manager can undo.",
+	},
+};
+// Jev has a ~32K context window. Warn well before that so the caller can trim state.
+const SIZE_WARN_TOKENS = 30_000;
+
+// ── Parameter schema ──
+
+const NoulQuestion = Type.Object({
+	name: Type.String({ description: "Identifier for this question, used as the key in the result" }),
+	type: Type.Literal("noul"),
+	instructions: Type.String({ description: "The yes/no condition to evaluate against the state" }),
+	criteria: Type.Optional(
+		Type.Object(
+			{
+				true: Type.String({ description: "What counts as yes" }),
+				false: Type.String({ description: "What counts as no" }),
+			},
+			{ description: "Optional descriptions of both outcomes. If given, both keys are required." },
+		),
+	),
+});
+
+const ChoiceQuestion = Type.Object({
+	name: Type.String({ description: "Identifier for this question, used as the key in the result" }),
+	type: Type.Literal("choice"),
+	instructions: Type.String({ description: "The single-choice question to answer" }),
+	criteria: Type.Record(Type.String(), Type.String(), {
+		description:
+			"Option name -> description. At least two options. Add an 'other' option when the set is not exhaustive.",
+	}),
+});
+
+const ScoreQuestion = Type.Object({
+	name: Type.String({ description: "Identifier for this question, used as the key in the result" }),
+	type: Type.Literal("score"),
+	instructions: Type.String({ description: "What to rate on the ordinal scale" }),
+	criteria: Type.Array(Type.String(), {
+		minItems: 2,
+		maxItems: 10,
+		description: "Ordered scale labels from lowest to highest, 2-10 items",
+	}),
+});
+
+const Question = Type.Union([NoulQuestion, ChoiceQuestion, ScoreQuestion]);
+
+const DecideParams = Type.Object({
+	state: Type.String({
+		description:
+			"The content to judge: a message, diff, log line, file excerpt, or a JSON string. " +
+			"Include only what the questions need; keep it well under 32K tokens.",
+	}),
+	questions: Type.Array(Question, {
+		minItems: 1,
+		description: "One or more typed questions about the state. Asking several at once costs the same as one.",
+	}),
+});
+
+type DecideParamsType = Static<typeof DecideParams>;
+type QuestionType = Static<typeof Question>;
+
+// ── API contract ──
+
+interface NoulAnswer {
+	type: "noul";
+	noul: number;
+}
+
+interface ChoiceAnswer {
+	type: "choice";
+	choice: string;
+	probabilities: Record<string, number>;
+	confidence: number;
+}
+
+interface ScoreAnswer {
+	type: "score";
+	score: number;
+	probabilities: Record<string, number>;
+	legend: Record<string, string>;
+	confidence: number;
+}
+
+type Answer = NoulAnswer | ChoiceAnswer | ScoreAnswer;
+
+interface DecisionsUsage {
+	input_tokens?: number;
+	output_tokens?: number;
+	cost?: number;
+}
+
+interface DecisionsResponse {
+	id?: string;
+	model?: string;
+	answers: Record<string, Answer>;
+	usage?: DecisionsUsage;
+}
+
+interface DecideDetails {
+	model?: string;
+	answers?: Record<string, Answer>;
+	usage?: DecisionsUsage;
+}
+
+type ApiQuestion = Omit<QuestionType, "name">;
+
+export default function (elyra: ExtensionAPI): void {
+	elyra.registerTool({
+		name: "decide",
+		label: "Jev Decision",
+		description:
+			"Ask TypeSafe Jev for calibrated judgements about a piece of content. " +
+			"Jev is a fast, cheap decision model (about 1 second, ~$0.00002 per call) that returns " +
+			"probabilities instead of prose. Use it to classify, gate, triage, or rank without spending " +
+			"main-model tokens: 'is this command destructive?', 'which category does this issue belong to?', " +
+			"'how severe is this log line on a 1-5 scale?'. " +
+			"Question types: 'noul' (yes/no with probability), 'choice' (pick one option with a distribution), " +
+			"'score' (ordinal scale with expected value). " +
+			"Write literal, observable criteria; Jev does not infer intent beyond what is stated.",
+		promptSnippet: "Get calibrated yes/no, choice, or score judgements from the Jev decision model",
+		parameters: DecideParams,
+		execute: async (_toolCallId, params, signal, _onUpdate, ctx) => {
+			validateQuestions(params.questions);
+
+			const apiKey = await requireApiKey(ctx);
+			const state = parseState(params.state);
+			const questions = toApiQuestions(params.questions);
+			const warning = sizeWarning(state, questions);
+			const response = await requestDecision(apiKey, state, questions, signal);
+			const text = formatResponse(params.questions, response);
+
+			return {
+				content: [{ type: "text", text: warning ? `${warning}\n\n${text}` : text }],
+				details: {
+					model: response.model,
+					answers: response.answers,
+					usage: response.usage,
+				} satisfies DecideDetails,
+			};
+		},
+	});
+
+	// ── Bash gate ──
+
+	elyra.registerFlag(FLAG_GATE, {
+		description: "Ask the Jev decision model whether each bash command is destructive before running it",
+		type: "boolean",
+		default: false,
+	});
+
+	let gateEnabled = elyra.getFlag(FLAG_GATE) === true || isTruthy(process.env[ENV_GATE]);
+	const gateThreshold = parseThreshold(process.env[ENV_GATE_THRESHOLD]);
+
+	elyra.on("tool_call", async (event, ctx) => {
+		if (!gateEnabled || event.toolName !== "bash") return undefined;
+
+		const command = event.input.command;
+		if (typeof command !== "string" || !command.trim()) return undefined;
+
+		const apiKey = await ctx.modelRegistry.getApiKeyForProvider(PROVIDER);
+		if (!apiKey) {
+			ctx.ui.notify("Jev bash gate: no OpenRouter API key, skipping check", "warning");
+			return undefined;
+		}
+
+		let probability: number;
+		try {
+			const response = await requestDecision(
+				apiKey,
+				{ command, cwd: ctx.cwd },
+				{ [GATE_QUESTION_NAME]: GATE_QUESTION },
+				ctx.signal,
+			);
+			const answer = response.answers[GATE_QUESTION_NAME];
+			if (!answer || answer.type !== "noul") {
+				ctx.ui.notify("Jev bash gate: unexpected response, skipping check", "warning");
+				return undefined;
+			}
+			probability = answer.noul;
+		} catch (error) {
+			if (ctx.signal?.aborted) return undefined;
+			const msg = error instanceof Error ? error.message : String(error);
+			ctx.ui.notify(`Jev bash gate: ${msg}. Skipping check.`, "warning");
+			return undefined;
+		}
+
+		if (probability < gateThreshold) return undefined;
+
+		const pct = `${Math.round(probability * 100)}%`;
+		if (!ctx.hasUI) {
+			return {
+				block: true,
+				reason: `Jev rated this command ${pct} likely destructive (threshold ${gateThreshold})`,
+			};
+		}
+
+		const allowed = await ctx.ui.confirm(`Jev: ${pct} likely destructive`, `${command}\n\nRun this command?`);
+		return allowed ? undefined : { block: true, reason: "Blocked by user after Jev destructive-command check" };
+	});
+
+	// ── Command ──
+
+	elyra.registerCommand("jev", {
+		description: "Jev decision model: show config, or `gate on|off` to toggle the bash gate",
+		handler: async (args: string, ctx) => {
+			const [sub, value] = args.trim().split(/\s+/);
+			if (sub === "gate") {
+				if (value === "on") gateEnabled = true;
+				else if (value === "off") gateEnabled = false;
+				else if (value) {
+					ctx.ui.notify("Usage: /jev gate on|off", "warning");
+					return;
+				}
+				ctx.ui.notify(`Jev bash gate: ${gateEnabled ? "on" : "off"} (threshold ${gateThreshold})`, "info");
+				return;
+			}
+
+			const apiKey = await ctx.modelRegistry.getApiKeyForProvider(PROVIDER);
+			const lines = [
+				`Model: ${process.env[ENV_MODEL] || DEFAULT_MODEL}`,
+				`Endpoint: ${process.env[ENV_BASE_URL] || DEFAULT_BASE_URL}`,
+				`OpenRouter key: ${apiKey ? "configured" : "missing (run /login or set OPENROUTER_API_KEY)"}`,
+				`Bash gate: ${gateEnabled ? "on" : "off"} (threshold ${gateThreshold}, toggle with /jev gate on|off)`,
+			];
+			ctx.ui.notify(lines.join("\n"), apiKey ? "info" : "warning");
+		},
+	});
+}
+
+// ── Config helpers ──
+
+function isTruthy(value: string | undefined): boolean {
+	if (!value) return false;
+	return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
+}
+
+function parseThreshold(value: string | undefined): number {
+	if (!value) return DEFAULT_GATE_THRESHOLD;
+	const parsed = Number.parseFloat(value);
+	if (!Number.isFinite(parsed) || parsed <= 0 || parsed > 1) return DEFAULT_GATE_THRESHOLD;
+	return parsed;
+}
+
+async function requireApiKey(ctx: ExtensionContext): Promise<string> {
+	const apiKey = await ctx.modelRegistry.getApiKeyForProvider(PROVIDER);
+	if (!apiKey) {
+		throw new Error("No OpenRouter API key found. Run /login and pick OpenRouter, or set OPENROUTER_API_KEY.");
+	}
+	return apiKey;
+}
+
+// ── Validation ──
+
+function validateQuestions(questions: QuestionType[]): void {
+	const seen = new Set<string>();
+	for (const q of questions) {
+		if (!q.name.trim()) {
+			throw new Error("Question name must not be empty");
+		}
+		if (seen.has(q.name)) {
+			throw new Error(`Duplicate question name: ${q.name}`);
+		}
+		seen.add(q.name);
+		if (!q.instructions.trim()) {
+			throw new Error(`Question "${q.name}" is missing instructions`);
+		}
+		switch (q.type) {
+			case "choice": {
+				if (Object.keys(q.criteria).length < 2) {
+					throw new Error(`Question "${q.name}" (choice) needs at least two options`);
+				}
+				break;
+			}
+			case "score": {
+				if (q.criteria.length < 2 || q.criteria.length > 10) {
+					throw new Error(`Question "${q.name}" (score) needs 2-10 scale labels`);
+				}
+				break;
+			}
+			case "noul": {
+				// Schema already enforces both keys when criteria is present.
+				break;
+			}
+		}
+	}
+}
+
+// ── Request building ──
+
+function parseState(raw: string): string | Record<string, unknown> | unknown[] {
+	const trimmed = raw.trim();
+	if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+		try {
+			const parsed: unknown = JSON.parse(trimmed);
+			if (parsed !== null && typeof parsed === "object") {
+				return parsed as Record<string, unknown> | unknown[];
+			}
+		} catch {
+			// Not JSON after all; send as text.
+		}
+	}
+	return trimmed;
+}
+
+function toApiQuestions(questions: QuestionType[]): Record<string, ApiQuestion> {
+	const out: Record<string, ApiQuestion> = {};
+	for (const q of questions) {
+		const { name, ...rest } = q;
+		out[name] = rest;
+	}
+	return out;
+}
+
+function estimateTokens(text: string): number {
+	let ascii = 0;
+	for (const ch of text) {
+		if (ch.charCodeAt(0) < 128) ascii++;
+	}
+	const nonAscii = text.length - ascii;
+	return ascii / 4 + nonAscii;
+}
+
+function sizeWarning(state: unknown, questions: Record<string, ApiQuestion>): string | undefined {
+	const stateText = typeof state === "string" ? state : JSON.stringify(state);
+	let longest = 0;
+	for (const q of Object.values(questions)) {
+		longest = Math.max(longest, estimateTokens(JSON.stringify(q)));
+	}
+	const total = estimateTokens(stateText) + longest;
+	if (total > SIZE_WARN_TOKENS) {
+		return `Warning: estimated ${Math.round(total)} tokens, which may exceed the model's ~32K context. Trim the state.`;
+	}
+	return undefined;
+}
+
+// ── HTTP ──
+
+function requestDecision(
+	apiKey: string,
+	state: unknown,
+	questions: Record<string, ApiQuestion>,
+	signal: AbortSignal | undefined,
+): Promise<DecisionsResponse> {
+	return callDecisions(apiKey, { model: process.env[ENV_MODEL] || DEFAULT_MODEL, state, questions }, signal);
+}
+
+async function callDecisions(
+	apiKey: string,
+	payload: Record<string, unknown>,
+	signal: AbortSignal | undefined,
+): Promise<DecisionsResponse> {
+	const url = process.env[ENV_BASE_URL] || DEFAULT_BASE_URL;
+	const headers = {
+		Authorization: `Bearer ${apiKey}`,
+		"Content-Type": "application/json",
+		"X-Title": "elyra-jev-tools",
+		"HTTP-Referer": "https://github.com/kwhorne/elyra",
+	};
+
+	for (let attempt = 1; ; attempt++) {
+		signal?.throwIfAborted();
+		const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+		const combined = signal ? AbortSignal.any([signal, timeout]) : timeout;
+
+		let response: Response;
+		try {
+			response = await fetch(url, {
+				method: "POST",
+				headers,
+				body: JSON.stringify(payload),
+				signal: combined,
+			});
+		} catch (error) {
+			if (signal?.aborted) throw error;
+			if (attempt >= MAX_ATTEMPTS) {
+				const msg = error instanceof Error ? error.message : String(error);
+				throw new Error(`Jev request failed: ${msg}`);
+			}
+			await sleep(backoffDelay(attempt), signal);
+			continue;
+		}
+
+		if (response.ok) {
+			const data = (await response.json()) as Partial<DecisionsResponse>;
+			if (!data.answers || typeof data.answers !== "object") {
+				throw new Error("Jev response is missing 'answers'");
+			}
+			return data as DecisionsResponse;
+		}
+
+		const body = await response.text();
+		const retryable = response.status === 429 || response.status === 529 || response.status >= 500;
+		if (retryable && attempt < MAX_ATTEMPTS) {
+			await sleep(backoffDelay(attempt, response.headers.get("Retry-After")), signal);
+			continue;
+		}
+		throw new Error(formatApiError(response.status, body));
+	}
+}
+
+function backoffDelay(attempt: number, retryAfter?: string | null): number {
+	if (retryAfter) {
+		const seconds = Number.parseFloat(retryAfter);
+		if (Number.isFinite(seconds)) return seconds * 1000;
+	}
+	const base = Math.min(20_000, 500 * 2 ** (attempt - 1));
+	return base + Math.random() * base * 0.5;
+}
+
+function sleep(ms: number, signal: AbortSignal | undefined): Promise<void> {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal?.reason instanceof Error ? signal.reason : new Error("Aborted"));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+
+function formatApiError(status: number, body: string): string {
+	let message = body.trim() || `HTTP ${status}`;
+	try {
+		const parsed = JSON.parse(body) as { error?: { message?: string } | string };
+		if (typeof parsed.error === "string") {
+			message = parsed.error;
+		} else if (parsed.error?.message) {
+			message = parsed.error.message;
+		}
+	} catch {
+		// Non-JSON body; keep raw text.
+	}
+	const hint = status === 401 ? " -- check that the OpenRouter API key is valid" : "";
+	return `Jev API error (HTTP ${status}): ${message}${hint}`;
+}
+
+// ── Output formatting ──
+
+function formatResponse(questions: QuestionType[], response: DecisionsResponse): string {
+	const lines: string[] = [];
+	for (const q of questions) {
+		const answer = response.answers[q.name];
+		if (!answer) {
+			lines.push(`${q.name}: (no answer returned)`);
+			continue;
+		}
+		lines.push(...formatAnswer(q.name, answer));
+	}
+
+	const usage = response.usage;
+	if (usage) {
+		const tokens = (usage.input_tokens ?? 0) + (usage.output_tokens ?? 0);
+		const cost = usage.cost !== undefined ? ` · $${usage.cost.toFixed(6)}` : "";
+		lines.push("", `[${response.model ?? DEFAULT_MODEL} · ${tokens} tok${cost}]`);
+	}
+	return lines.join("\n");
+}
+
+function formatAnswer(name: string, answer: Answer): string[] {
+	switch (answer.type) {
+		case "noul": {
+			const p = answer.noul ?? 0;
+			return [`${name}: ${p >= 0.5 ? "yes" : "no"} (p=${p.toFixed(2)})`];
+		}
+		case "choice": {
+			const probs = answer.probabilities ?? {};
+			const p = probs[answer.choice] ?? 0;
+			const dist = Object.entries(probs)
+				.sort((a, b) => b[1] - a[1])
+				.map(([k, v]) => `${k}=${v.toFixed(2)}`)
+				.join(", ");
+			return [
+				`${name}: ${answer.choice} (p=${p.toFixed(2)}, conf=${(answer.confidence ?? 0).toFixed(2)})`,
+				`  ${dist}`,
+			];
+		}
+		case "score": {
+			const legend = answer.legend ?? {};
+			const probs = answer.probabilities ?? {};
+			const maxIdx = Math.max(0, Object.keys(legend).length - 1);
+			const argmax = Object.keys(probs).sort((a, b) => (probs[b] ?? 0) - (probs[a] ?? 0))[0];
+			const label = argmax !== undefined ? (legend[argmax] ?? argmax) : "";
+			const dist = Object.keys(legend)
+				.sort((a, b) => Number(a) - Number(b))
+				.map((k) => `${legend[k]}=${(probs[k] ?? 0).toFixed(2)}`)
+				.join(", ");
+			return [
+				`${name}: ${(answer.score ?? 0).toFixed(2)}/${maxIdx} -> ${label} (conf=${(answer.confidence ?? 0).toFixed(2)})`,
+				`  ${dist}`,
+			];
+		}
+		default: {
+			return [`${name}: ${JSON.stringify(answer)}`];
+		}
+	}
+}
+
+export type { DecideDetails, DecideParamsType as DecideParams };

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@elyracode/jev-tools",
+  "version": "0.9.39",
+  "description": "Elyra extension for TypeSafe Jev decisions via OpenRouter -- calibrated yes/no, choice, and score judgements",
+  "type": "module",
+  "keywords": [
+    "elyra-package",
+    "jev",
+    "typesafe",
+    "openrouter",
+    "decisions",
+    "classification"
+  ],
+  "license": "MIT",
+  "author": "Knut W. Horne",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kwhorne/elyra.git",
+    "directory": "packages/jev-tools"
+  },
+  "elyra": {
+    "extensions": [
+      "./extensions/index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@elyracode/coding-agent": "*",
+    "typebox": "*"
+  },
+  "scripts": {
+    "clean": "echo 'nothing to clean'",
+    "build": "echo 'nothing to build'",
+    "check": "echo 'nothing to check'"
+  }
+}