@pragma-sh/junie-plugin 0.1.0-alpha.0

package/dist/pragma-plugin.mjs

@@ -0,0 +1,700 @@
+// ../plugin/dist/shared/chunk-k5kqv14t.js
+var PLUGIN_API_VERSION = "0.0.0";
+
+// ../plugin/dist/shared/chunk-0rpz2gg0.js
+function defineAgent(input) {
+  return input;
+}
+function definePlugin(input) {
+  return { ...input, __apiVersion: PLUGIN_API_VERSION };
+}
+function defineUsageLimitProvider(input) {
+  return input;
+}
+
+// ../watcher-kit/src/index.ts
+var DEFAULT_APPROVE_KEYS = "\r";
+var RIGHT_ARROW = "\x1B[C";
+var DOWN_ARROW = "\x1B[B";
+var DEFAULT_DENY_KEYS = `${RIGHT_ARROW}${RIGHT_ARROW}\r`;
+var DEFAULT_SUBMIT_KEYS = "\r";
+var BRACKETED_PASTE_START = "\x1B[200~";
+var BRACKETED_PASTE_END = "\x1B[201~";
+var QUESTION_REJECT_KEYS = "\x1B";
+var QUESTION_DIGIT_MAX = 9;
+var QUESTION_PROMPT_MOUNT_DELAY_MS = 150;
+var QUESTION_OTHER_INPUT_DELAY_MS = 150;
+var QUESTION_NEXT_PROMPT_DELAY_MS = 500;
+var ANSWER_SEPARATOR = "\x1F";
+var RESUBSCRIBE_DELAY_MS = 500;
+var DEFAULT_INTERJECT_SUBMIT_DELAY_MS = 200;
+function createTuiWatcher(options) {
+  const {
+    agent,
+    handleDecisions,
+    handleQuestionAnswers = handleDecisions,
+    interjectSubmitDelayMs = DEFAULT_INTERJECT_SUBMIT_DELAY_MS,
+    interjectMode = "bracketed",
+    interjectSubmitKeys,
+    questionSelectMode = "digit",
+    questionOtherMode = "navigate-enter",
+    questionDismissKeys = QUESTION_REJECT_KEYS,
+    questionFinalizeKeys = ""
+  } = options;
+  return {
+    agent,
+    async watch(ctx) {
+      const watcherContext = ctx;
+      const runtime = {
+        keys: resolveKeys(watcherContext.config, interjectSubmitKeys),
+        handleDecisions,
+        handleQuestionAnswers,
+        interjectSubmitDelayMs,
+        interjectMode,
+        questionSelectMode,
+        questionOtherMode,
+        questionDismissKeys,
+        questionFinalizeKeys,
+        seenRequestIds: new Set,
+        questionsByRequestId: new Map,
+        outstandingCommandRequestId: null
+      };
+      let failures = 0;
+      while (!ctx.signal.aborted) {
+        try {
+          await consumeControlEvents(watcherContext, runtime);
+          failures = 0;
+        } catch (error) {
+          failures += 1;
+          reportStreamFailure(agent, failures, error);
+        }
+        if (ctx.signal.aborted) {
+          return;
+        }
+        await delay(RESUBSCRIBE_DELAY_MS, ctx.signal);
+      }
+    }
+  };
+}
+function reportStreamFailure(agent, consecutive, error) {
+  if (consecutive !== 1 && consecutive % STREAM_FAILURE_LOG_EVERY !== 0) {
+    return;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(JSON.stringify({ type: "watcher.streamError", agent, consecutive, error: message }));
+}
+var STREAM_FAILURE_LOG_EVERY = 240;
+function resolveKeys(config, interjectSubmitKeys) {
+  const c = config ?? {};
+  return {
+    approveKeys: c.approveKeys ?? DEFAULT_APPROVE_KEYS,
+    denyKeys: c.denyKeys ?? DEFAULT_DENY_KEYS,
+    submitKeys: c.submitKeys ?? interjectSubmitKeys ?? DEFAULT_SUBMIT_KEYS
+  };
+}
+async function consumeControlEvents(ctx, runtime) {
+  const connection = await ctx.sdk.agents.connect({
+    agent: ctx.agentId,
+    tabId: ctx.session.tabId,
+    worktreeId: ctx.session.worktreeId,
+    signal: ctx.signal
+  });
+  for await (const event of connection) {
+    if (ctx.signal.aborted) {
+      return;
+    }
+    await handleControlEvent(ctx, runtime, event);
+  }
+}
+async function handleControlEvent(ctx, runtime, event) {
+  if (event.type === "agent") {
+    if (runtime.handleQuestionAnswers)
+      rememberQuestion(runtime.questionsByRequestId, event);
+    if (runtime.handleDecisions)
+      rememberCommandAttention(runtime, event);
+    return;
+  }
+  if (runtime.handleDecisions && await handleDecision(ctx, runtime, event)) {
+    return;
+  }
+  if (runtime.handleQuestionAnswers && await handleAnswer(ctx, runtime, event)) {
+    return;
+  }
+  if (event.type === "agentInput") {
+    await handleInterjection(ctx, runtime.keys.submitKeys, runtime.interjectSubmitDelayMs, runtime.interjectMode, event.input.text);
+  }
+}
+async function handleDecision(ctx, runtime, event) {
+  if (event.type !== "agentDecision")
+    return false;
+  if (runtime.seenRequestIds.has(event.decision.requestId))
+    return true;
+  runtime.seenRequestIds.add(event.decision.requestId);
+  if (runtime.outstandingCommandRequestId !== null && runtime.outstandingCommandRequestId !== event.decision.requestId) {
+    return true;
+  }
+  runtime.outstandingCommandRequestId = null;
+  await writeKeys(ctx, event.decision.approved ? runtime.keys.approveKeys : runtime.keys.denyKeys);
+  return true;
+}
+async function handleAnswer(ctx, runtime, event) {
+  if (event.type !== "agentAnswer")
+    return false;
+  const { answer } = event;
+  const cached = runtime.questionsByRequestId.get(answer.requestId);
+  if (!cached)
+    return true;
+  if (runtime.seenRequestIds.has(answer.requestId))
+    return true;
+  runtime.seenRequestIds.add(answer.requestId);
+  runtime.questionsByRequestId.delete(answer.requestId);
+  await delay(QUESTION_PROMPT_MOUNT_DELAY_MS, ctx.signal);
+  if (ctx.signal.aborted)
+    return true;
+  const reply = answer.answer?.trim() ?? null;
+  if (cached.questions.length > 1) {
+    if (!answer.dismissed && reply) {
+      await writeMultipleQuestionAnswers(ctx, runtime, cached.questions, reply);
+    } else if (answer.dismissed || !reply) {
+      await writeKeys(ctx, runtime.questionDismissKeys);
+    }
+    return true;
+  }
+  const single = cached.questions[0] ?? { question: "", options: [] };
+  await writeQuestionAnswer(ctx, runtime, single, reply, answer.dismissed);
+  if (!answer.dismissed && reply)
+    await finalizeQuestionAnswers(ctx, runtime);
+  return true;
+}
+async function writeQuestionAnswer(ctx, runtime, question, reply, dismissed) {
+  if (dismissed || !reply) {
+    await writeKeys(ctx, runtime.questionDismissKeys);
+    return;
+  }
+  if (!dismissed && reply && !question.options.includes(reply)) {
+    await writeFreeTextAnswer(ctx, question.options.length, reply, runtime.questionSelectMode, runtime.questionOtherMode);
+    return;
+  }
+  const strokes = questionAnswerKeys({
+    dismissed,
+    reply,
+    options: question.options,
+    selectMode: runtime.questionSelectMode
+  });
+  if (strokes)
+    await writeKeys(ctx, strokes);
+}
+async function writeFreeTextAnswer(ctx, optionCount, reply, selectMode, otherMode) {
+  await writeKeys(ctx, openOtherEditorKeys(optionCount, selectMode, otherMode));
+  await delay(QUESTION_OTHER_INPUT_DELAY_MS, ctx.signal);
+  if (!ctx.signal.aborted)
+    await writeKeys(ctx, `${reply}\r`);
+}
+async function writeMultipleQuestionAnswers(ctx, runtime, questions, combined) {
+  const replies = combined.split(ANSWER_SEPARATOR).map((reply) => reply.trim());
+  for (const [index, question] of questions.entries()) {
+    const reply = replies[index];
+    if (!reply || ctx.signal.aborted)
+      return;
+    await writeQuestionAnswer(ctx, runtime, question, reply, false);
+    if (index < questions.length - 1) {
+      await delay(QUESTION_NEXT_PROMPT_DELAY_MS, ctx.signal);
+    }
+  }
+  await finalizeQuestionAnswers(ctx, runtime);
+}
+async function finalizeQuestionAnswers(ctx, runtime) {
+  if (!runtime.questionFinalizeKeys || ctx.signal.aborted)
+    return;
+  await delay(QUESTION_NEXT_PROMPT_DELAY_MS, ctx.signal);
+  if (!ctx.signal.aborted)
+    await writeKeys(ctx, runtime.questionFinalizeKeys);
+}
+async function handleInterjection(ctx, submitKeys, submitDelayMs, mode, text) {
+  const input = mode === "plain" ? text : `${BRACKETED_PASTE_START}${text}${BRACKETED_PASTE_END}`;
+  await writeKeys(ctx, input);
+  if (!submitKeys) {
+    return;
+  }
+  await delay(submitDelayMs, ctx.signal);
+  if (!ctx.signal.aborted)
+    await writeKeys(ctx, submitKeys);
+}
+function rememberCommandAttention(runtime, event) {
+  if (event.status === "attention" && event.attentionKind === "command" && typeof event.requestId === "string" && event.requestId.length > 0) {
+    runtime.outstandingCommandRequestId = event.requestId;
+    return;
+  }
+  if (event.status !== "attention") {
+    runtime.outstandingCommandRequestId = null;
+  }
+}
+function rememberQuestion(cache, event) {
+  if (event.status === "attention" && event.attentionKind === "question" && typeof event.requestId === "string" && event.requestId.length > 0) {
+    const entries = (event.questions ?? []).flatMap(questionEntry);
+    if (entries.length > 0) {
+      cache.set(event.requestId, { questions: entries });
+      return;
+    }
+    const options = (event.options ?? []).map((option) => option.label).filter((option) => option.trim() !== "");
+    cache.set(event.requestId, {
+      questions: [{ question: event.question ?? "", options }]
+    });
+  }
+}
+function questionEntry(value) {
+  if (typeof value !== "object" || value === null || !("question" in value)) {
+    return [];
+  }
+  const record = value;
+  if (typeof record.question !== "string" || !record.question.trim()) {
+    return [];
+  }
+  const options = Array.isArray(record.options) ? record.options.filter((option) => Boolean(option) && typeof option === "object").map((option) => option.label).filter((label) => typeof label === "string" && label.trim() !== "") : [];
+  return [{ question: record.question, options }];
+}
+function questionAnswerKeys(input) {
+  if (input.dismissed || input.reply === null) {
+    return QUESTION_REJECT_KEYS;
+  }
+  const reply = input.reply.trim();
+  if (!reply) {
+    return QUESTION_REJECT_KEYS;
+  }
+  const options = input.options;
+  const selectMode = input.selectMode ?? "digit";
+  const matchIndex = options.findIndex((option) => option === reply);
+  if (matchIndex >= 0) {
+    return selectOptionKeys(matchIndex, options.length, selectMode);
+  }
+  return `${openOtherEditorKeys(options.length, selectMode, "navigate-enter")}${reply}\r`;
+}
+function openOtherEditorKeys(optionCount, selectMode, otherMode) {
+  if (otherMode === "shortcut-z")
+    return "z";
+  const navigate = DOWN_ARROW.repeat(optionCount);
+  return selectMode === "arrow-space" || otherMode === "navigate" ? navigate : `${navigate}\r`;
+}
+function selectOptionKeys(index, optionCount, selectMode) {
+  if (selectMode === "arrow-space") {
+    return `${DOWN_ARROW.repeat(index)} \r`;
+  }
+  const total = optionCount + 1;
+  if (index < QUESTION_DIGIT_MAX && index < total) {
+    return String(index + 1);
+  }
+  return `${DOWN_ARROW.repeat(index)}\r`;
+}
+async function writeKeys(ctx, data) {
+  try {
+    await ctx.sendKeys(data);
+  } catch {}
+}
+function delay(ms, signal) {
+  if (signal.aborted) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const finish = () => resolve();
+    const timer = setTimeout(finish, ms);
+    signal.addEventListener("abort", () => {
+      clearTimeout(timer);
+      finish();
+    }, { once: true });
+  });
+}
+
+// src/acp.ts
+var MISSING_STATUS = 20;
+var INITIALIZE_ID = 1;
+var SESSION_ID = 2;
+var PROMPT_ID = 3;
+var POLL_SECONDS = "0.1";
+var POLL_ATTEMPTS = 900;
+var SHELL_PROBE = "(command -v sh >/dev/null 2>&1) && exit 0 || exit 1";
+async function readJunieAcp(ctx, options) {
+  const cwd = ctx.project?.path ?? "/tmp";
+  const [shell] = await ctx.sdk.exec.run({ cwd, commands: [SHELL_PROBE] });
+  if (shell?.status !== 0) {
+    return { missing: false, unsupportedShell: true, session: undefined, usageText: null };
+  }
+  const [result] = await ctx.sdk.exec.run({ cwd, commands: [buildCommand(options.usage)] });
+  if (result?.status === MISSING_STATUS) {
+    return { missing: true, unsupportedShell: false, session: undefined, usageText: null };
+  }
+  if (!result || result.status !== 0) {
+    throw new Error(result?.stderr.trim() || "Junie ACP request failed");
+  }
+  return {
+    missing: false,
+    unsupportedShell: false,
+    session: findResponse(result.stdout, SESSION_ID),
+    usageText: options.usage ? collectAgentText(result.stdout) : null
+  };
+}
+function buildCommand(usage) {
+  const finalId = usage ? PROMPT_ID : SESSION_ID;
+  return [
+    `command -v junie >/dev/null 2>&1 || exit ${MISSING_STATUS};`,
+    "work=$(mktemp -d) || exit 1;",
+    `trap 'rm -rf "$work"' 0;`,
+    'mkfifo "$work/in" || exit 1;',
+    "{",
+    `printf '%s\\n' ${shellQuote(request(INITIALIZE_ID, "initialize", { protocolVersion: 1, clientCapabilities: {} }))};`,
+    `printf '%s\\n' '{"jsonrpc":"2.0","id":${SESSION_ID},"method":"session/new","params":{"cwd":"'"$PWD"'","mcpServers":[]}}';`,
+    ...usage ? [
+      "n=0;",
+      `while [ ! -s "$work/next" ] && [ ! -e "$work/done" ] && [ "$n" -lt ${POLL_ATTEMPTS} ]; do sleep ${POLL_SECONDS}; n=$((n + 1)); done;`,
+      '[ -s "$work/next" ] && cat "$work/next";'
+    ] : [],
+    "n=0;",
+    `while [ ! -e "$work/done" ] && [ "$n" -lt ${POLL_ATTEMPTS} ]; do sleep ${POLL_SECONDS}; n=$((n + 1)); done;`,
+    '} >"$work/in" &',
+    'junie --acp=true --skip-update-check --cache-dir "$work/cache" <"$work/in" 2>/dev/null |',
+    "while IFS= read -r line; do",
+    `printf '%s\\n' "$line";`,
+    ...usage ? [
+      `case "$line" in *'"sessionId":"'*)`,
+      'if [ ! -s "$work/next" ]; then',
+      `sid=$(printf '%s' "$line" | sed -n 's/.*"sessionId":"\\([^"]*\\)".*/\\1/p' | head -n 1);`,
+      'if [ -n "$sid" ]; then',
+      `printf '{"jsonrpc":"2.0","id":${PROMPT_ID},"method":"session/prompt","params":{"sessionId":"%s","prompt":[{"type":"text","text":"/usage"}]}}\\n' "$sid" >"$work/next";`,
+      "fi;",
+      "fi;",
+      ";; esac;"
+    ] : [],
+    `case "$line" in *'"id":${finalId}'*) : >"$work/done" ;; esac;`,
+    "done"
+  ].join(" ");
+}
+function request(id, method, params) {
+  return JSON.stringify({ jsonrpc: "2.0", id, method, params });
+}
+function findResponse(stdout, id) {
+  for (const line of stdout.split(`
+`)) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const record = asRecord(message);
+    if (record === null || record.id !== id) {
+      continue;
+    }
+    if ("result" in record) {
+      return { ok: true, result: record.result };
+    }
+    return { ok: false, message: asText(asRecord(record.error)?.message) };
+  }
+  return;
+}
+function collectAgentText(stdout) {
+  const parts = [];
+  for (const line of stdout.split(`
+`)) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const update = asRecord(asRecord(asRecord(message)?.params)?.update);
+    if (update?.sessionUpdate !== "agent_message_chunk") {
+      continue;
+    }
+    const text = asText(asRecord(update.content)?.text);
+    if (text !== null) {
+      parts.push(text);
+    }
+  }
+  return parts.join("");
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return null;
+  }
+  return value;
+}
+function asText(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+// src/usage-limits.ts
+var PRIMARY_LIMIT_ID = "credits";
+var PEAKS_DIR = '"$HOME"/.pragma/cache';
+var PEAKS_FILE = `${PEAKS_DIR}/junie-usage.json`;
+var PEAKS_VERSION = 1;
+async function loadJunieUsageLimits(ctx) {
+  const { missing, unsupportedShell, usageText } = await readJunieAcp(ctx, { usage: true });
+  if (unsupportedShell) {
+    return {
+      status: "unavailable",
+      reason: "unsupported",
+      message: "Junie usage limits require a POSIX shell on the project's host."
+    };
+  }
+  if (missing) {
+    return {
+      status: "unavailable",
+      reason: "not-configured",
+      message: "Install the Junie CLI to load usage limits."
+    };
+  }
+  if (usageText === null || usageText.trim() === "") {
+    throw new Error("Junie returned no usage report");
+  }
+  if (/log ?in|sign ?in|authenticat|not authorized/i.test(usageText)) {
+    return {
+      status: "unavailable",
+      reason: "authentication-required",
+      message: "Run `junie` and sign in to your JetBrains account to load usage limits."
+    };
+  }
+  const usage = parseJunieUsage(usageText);
+  if (usage === null) {
+    return {
+      status: "unavailable",
+      reason: "unsupported",
+      message: "Junie did not report a balance for this license."
+    };
+  }
+  const peak = await recordPeak(ctx, peakKey(usage), usage.remaining);
+  return buildResult(usage, peak, Date.now());
+}
+function parseJunieUsage(text) {
+  const licenseType = /^\s*-?\s*License:\s*(.+?)\s*$/m.exec(text)?.[1] ?? null;
+  const money = /^\s*-?\s*Balance left:\s*([^\d\s]*)\s*([\d.,]+)\s*$/m.exec(text);
+  if (money) {
+    const remaining = parseAmount(money[2]);
+    return remaining === null ? null : { licenseType, remaining, unit: money[1] || "$" };
+  }
+  const credits = /^\s*-?\s*Quota:\s*([\d.,]+)\s*(\S+)?\s*remaining\s*$/m.exec(text);
+  if (credits) {
+    const remaining = parseAmount(credits[1]);
+    return remaining === null ? null : { licenseType, remaining, unit: credits[2] ?? "credits" };
+  }
+  return null;
+}
+function buildResult(usage, peak, observedAt) {
+  if (peak <= 0) {
+    return {
+      status: "unavailable",
+      reason: "unsupported",
+      message: `Junie reports no ${usage.unit === "$" ? "balance" : usage.unit} left.`
+    };
+  }
+  const limit = {
+    id: PRIMARY_LIMIT_ID,
+    title: usage.licenseType === null ? "Credits" : `${usage.licenseType} credits`,
+    used: Math.min(peak, Math.max(0, peak - usage.remaining)),
+    limit: peak
+  };
+  return { status: "ready", observedAt, limits: [limit] };
+}
+function peakKey(usage) {
+  return `${usage.licenseType ?? "unknown"}|${usage.unit}`;
+}
+async function recordPeak(ctx, key, remaining) {
+  const cwd = ctx.project?.path ?? "/tmp";
+  const file = parsePeaksFile(await readPeaksText(ctx, cwd));
+  const stored = file.peaks[key] ?? 0;
+  if (remaining <= stored) {
+    return stored;
+  }
+  file.peaks[key] = remaining;
+  try {
+    await writePeaksText(ctx, cwd, serializePeaksFile(file));
+  } catch {}
+  return remaining;
+}
+async function readPeaksText(ctx, cwd) {
+  try {
+    const [result] = await ctx.sdk.exec.run({
+      cwd,
+      commands: [`cat ${PEAKS_FILE} 2>/dev/null || true`]
+    });
+    return result?.stdout ?? "";
+  } catch {
+    return "";
+  }
+}
+async function writePeaksText(ctx, cwd, contents) {
+  const [result] = await ctx.sdk.exec.run({
+    cwd,
+    commands: [`mkdir -p ${PEAKS_DIR} && printf '%s\\n' ${shellQuote(contents)} > ${PEAKS_FILE}`]
+  });
+  if (!result || result.status !== 0) {
+    throw new Error(result?.stderr.trim() || "failed to write Junie usage cache");
+  }
+}
+function parsePeaksFile(text) {
+  const trimmed = text.trim();
+  if (trimmed === "") {
+    return { version: PEAKS_VERSION, peaks: {} };
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed !== "object" || parsed === null) {
+      return { version: PEAKS_VERSION, peaks: {} };
+    }
+    const record = parsed;
+    if (record.version !== PEAKS_VERSION || typeof record.peaks !== "object" || record.peaks === null) {
+      return { version: PEAKS_VERSION, peaks: {} };
+    }
+    const peaks = {};
+    for (const [key, value] of Object.entries(record.peaks)) {
+      if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+        peaks[key] = value;
+      }
+    }
+    return { version: PEAKS_VERSION, peaks };
+  } catch {
+    return { version: PEAKS_VERSION, peaks: {} };
+  }
+}
+function serializePeaksFile(file) {
+  return `${JSON.stringify(file, null, 2)}
+`;
+}
+function parseAmount(value) {
+  if (value === undefined) {
+    return null;
+  }
+  const parsed = Number.parseFloat(value.replaceAll(",", ""));
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+// src/pragma-plugin.ts
+var PREFILL_DELAY_MS = 6000;
+var USAGE_REFRESH_INTERVAL_MS = 900000;
+var baseWatcher = createTuiWatcher({
+  agent: "junie",
+  handleDecisions: false,
+  handleQuestionAnswers: true,
+  questionSelectMode: "arrow-space",
+  questionFinalizeKeys: "\r"
+});
+var junieAgentPlugin = definePlugin({
+  name: "Junie",
+  description: "Launch the JetBrains Junie CLI from Pragma.",
+  usageLimits: [
+    defineUsageLimitProvider({
+      id: "junie",
+      title: "Junie",
+      dashboardUrl: "https://junie.jetbrains.com/cli",
+      iconPath: "assets/junie.svg",
+      primaryLimitId: PRIMARY_LIMIT_ID,
+      refreshIntervalMs: USAGE_REFRESH_INTERVAL_MS,
+      load: loadJunieUsageLimits
+    })
+  ],
+  watchers: [
+    {
+      agent: "junie",
+      async watch(ctx) {
+        try {
+          await baseWatcher.watch(ctx);
+        } finally {
+          try {
+            await ctx.sdk.agents.report({
+              agent: ctx.agentId,
+              tabId: ctx.session.tabId,
+              worktreeId: ctx.session.worktreeId,
+              status: "cleared",
+              attentionKind: null
+            });
+          } catch {}
+        }
+      }
+    }
+  ],
+  agents: [
+    defineAgent({
+      id: "junie",
+      name: "Junie",
+      icon: () => null,
+      iconPath: "assets/junie.svg",
+      launch: { command: ["junie"] },
+      prefillDelayMs: PREFILL_DELAY_MS,
+      prefillMode: "plain",
+      prefillSubmit: "\r",
+      models: loadJunieModels,
+      permissionModes: [
+        { id: "default", name: "Ask for approval" },
+        { id: "brave", name: "Brave mode (no approvals)" }
+      ],
+      excludeFeatures: ["subagents"],
+      args: {
+        model: (modelId) => ["--model", modelId],
+        reasoning: (reasoningId) => ["--effort", reasoningId],
+        permissionMode: (permissionModeId) => permissionModeId === "brave" ? ["--brave"] : []
+      }
+    })
+  ]
+});
+var pragma_plugin_default = junieAgentPlugin;
+async function loadJunieModels(ctx) {
+  let snapshot;
+  try {
+    snapshot = await readJunieAcp(ctx, { usage: false });
+  } catch {
+    return [];
+  }
+  if (snapshot.missing || snapshot.session?.ok !== true) {
+    return [];
+  }
+  return parseJunieModels(snapshot.session.result);
+}
+function parseJunieModels(value) {
+  const options = asRecord(value)?.configOptions;
+  const reasoning = parseReasoning(findOption(options, "effort"));
+  const models = [];
+  for (const candidate of records(findOption(options, "model")?.options)) {
+    const id = asText(candidate.value);
+    if (id === null) {
+      continue;
+    }
+    const name = asText(candidate.name) ?? id;
+    models.push(reasoning.length > 0 ? { id, name, reasoning } : { id, name });
+  }
+  return models;
+}
+function findOption(value, id) {
+  return records(value).find((option) => asText(option.id) === id);
+}
+function parseReasoning(option) {
+  const entries = [];
+  for (const effort of records(option?.options)) {
+    const id = asText(effort.value);
+    if (id === null) {
+      continue;
+    }
+    entries.push({ id, name: asText(effort.name) ?? titleCase(id) });
+  }
+  return entries;
+}
+function records(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((entry) => {
+    const record = asRecord(entry);
+    return record === null ? [] : [record];
+  });
+}
+function titleCase(value) {
+  return `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}`;
+}
+export {
+  parseJunieUsage,
+  parseJunieModels,
+  loadJunieUsageLimits,
+  loadJunieModels,
+  junieAgentPlugin,
+  pragma_plugin_default as default
+};