jialing-code 1.1.0

package/dist/chunk-crfryjx9.js

@@ -0,0 +1,276 @@
+// @bun
+import {
+  getProjectDir,
+  getTranscriptPath,
+  getTranscriptPathForSession,
+  init_sessionStorage,
+  isTranscriptMessage,
+  saveCustomTitle,
+  searchSessionsByCustomTitle
+} from "./chunk-ewsgsw9h.js";
+import"./chunk-z1zj044v.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-key6jr7p.js";
+import"./chunk-0m2861gw.js";
+import"./chunk-0x9b2nmd.js";
+import"./chunk-89e1v45e.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-3be7ka25.js";
+import"./chunk-x679thag.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-bhdt6k7w.js";
+import"./chunk-45kxdsp8.js";
+import"./chunk-5dbk24zg.js";
+import"./chunk-msjfc5ba.js";
+import"./chunk-7zsapntc.js";
+import"./chunk-0rg6yrhy.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-x0mwzt38.js";
+import"./chunk-9e2kqv5g.js";
+import"./chunk-1qakq4sn.js";
+import"./chunk-s9mesaw0.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-tw0q7ynt.js";
+import"./chunk-xe9cc860.js";
+import"./chunk-m06q12hg.js";
+import"./chunk-ygbf0ezx.js";
+import"./chunk-spqaamnc.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-7sb5axvf.js";
+import"./chunk-v9smspw2.js";
+import {
+  escapeRegExp,
+  init_stringUtils
+} from "./chunk-3f7rypmf.js";
+import {
+  init_json,
+  parseJSONL
+} from "./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-vratq94g.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-6kpbgc5w.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-tjaqa99q.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-w2z5pqd3.js";
+import"./chunk-7ymfj7m3.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-1eapde8a.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-1rvz0433.js";
+import"./chunk-cdz5yb0r.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-f2mhrmww.js";
+import"./chunk-7z8j9qfn.js";
+import"./chunk-hrzerbfw.js";
+import"./chunk-d18z9pna.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-hjhc4cpt.js";
+import"./chunk-vyc0rjyx.js";
+import"./chunk-hx2tr4ep.js";
+import"./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import {
+  init_slowOperations,
+  jsonStringify
+} from "./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import {
+  getOriginalCwd,
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/branch/branch.ts
+import { randomUUID } from "crypto";
+import { mkdir, readFile, writeFile } from "fs/promises";
+function deriveFirstPrompt(firstUserMessage) {
+  const content = firstUserMessage?.message?.content;
+  if (!content)
+    return "Branched conversation";
+  const raw = typeof content === "string" ? content : content.find((block) => block.type === "text")?.text;
+  if (!raw)
+    return "Branched conversation";
+  return raw.replace(/\s+/g, " ").trim().slice(0, 100) || "Branched conversation";
+}
+async function createFork(customTitle) {
+  const forkSessionId = randomUUID();
+  const originalSessionId = getSessionId();
+  const projectDir = getProjectDir(getOriginalCwd());
+  const forkSessionPath = getTranscriptPathForSession(forkSessionId);
+  const currentTranscriptPath = getTranscriptPath();
+  await mkdir(projectDir, { recursive: true, mode: 448 });
+  let transcriptContent;
+  try {
+    transcriptContent = await readFile(currentTranscriptPath);
+  } catch {
+    throw new Error("No conversation to branch");
+  }
+  if (transcriptContent.length === 0) {
+    throw new Error("No conversation to branch");
+  }
+  const entries = parseJSONL(transcriptContent);
+  const mainConversationEntries = entries.filter((entry) => isTranscriptMessage(entry) && !entry.isSidechain);
+  const contentReplacementRecords = entries.filter((entry) => entry.type === "content-replacement" && entry.sessionId === originalSessionId).flatMap((entry) => entry.replacements);
+  if (mainConversationEntries.length === 0) {
+    throw new Error("No messages to branch");
+  }
+  let parentUuid = null;
+  const lines = [];
+  const serializedMessages = [];
+  for (const entry of mainConversationEntries) {
+    const forkedEntry = {
+      ...entry,
+      sessionId: forkSessionId,
+      parentUuid,
+      isSidechain: false,
+      forkedFrom: {
+        sessionId: originalSessionId,
+        messageUuid: entry.uuid
+      }
+    };
+    const serialized = {
+      ...entry,
+      sessionId: forkSessionId
+    };
+    serializedMessages.push(serialized);
+    lines.push(jsonStringify(forkedEntry));
+    if (entry.type !== "progress") {
+      parentUuid = entry.uuid;
+    }
+  }
+  if (contentReplacementRecords.length > 0) {
+    const forkedReplacementEntry = {
+      type: "content-replacement",
+      sessionId: forkSessionId,
+      replacements: contentReplacementRecords
+    };
+    lines.push(jsonStringify(forkedReplacementEntry));
+  }
+  await writeFile(forkSessionPath, lines.join(`
+`) + `
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  return {
+    sessionId: forkSessionId,
+    title: customTitle,
+    forkPath: forkSessionPath,
+    serializedMessages,
+    contentReplacementRecords
+  };
+}
+async function getUniqueForkName(baseName) {
+  const candidateName = `${baseName} (Branch)`;
+  const existingWithExactName = await searchSessionsByCustomTitle(candidateName, { exact: true });
+  if (existingWithExactName.length === 0) {
+    return candidateName;
+  }
+  const existingForks = await searchSessionsByCustomTitle(`${baseName} (Branch`);
+  const usedNumbers = new Set([1]);
+  const forkNumberPattern = new RegExp(`^${escapeRegExp(baseName)} \\(Branch(?: (\\d+))?\\)$`);
+  for (const session of existingForks) {
+    const match = session.customTitle?.match(forkNumberPattern);
+    if (match) {
+      if (match[1]) {
+        usedNumbers.add(parseInt(match[1], 10));
+      } else {
+        usedNumbers.add(1);
+      }
+    }
+  }
+  let nextNumber = 2;
+  while (usedNumbers.has(nextNumber)) {
+    nextNumber++;
+  }
+  return `${baseName} (Branch ${nextNumber})`;
+}
+async function call(onDone, context, args) {
+  const customTitle = args?.trim() || undefined;
+  const originalSessionId = getSessionId();
+  try {
+    const {
+      sessionId,
+      title,
+      forkPath,
+      serializedMessages,
+      contentReplacementRecords
+    } = await createFork(customTitle);
+    const now = new Date;
+    const firstPrompt = deriveFirstPrompt(serializedMessages.find((m) => m.type === "user"));
+    const baseName = title ?? firstPrompt;
+    const effectiveTitle = await getUniqueForkName(baseName);
+    await saveCustomTitle(sessionId, effectiveTitle, forkPath);
+    logEvent("tengu_conversation_forked", {
+      message_count: serializedMessages.length,
+      has_custom_title: !!title
+    });
+    const forkLog = {
+      date: now.toISOString().split("T")[0],
+      messages: serializedMessages,
+      fullPath: forkPath,
+      value: now.getTime(),
+      created: now,
+      modified: now,
+      firstPrompt,
+      messageCount: serializedMessages.length,
+      isSidechain: false,
+      sessionId,
+      customTitle: effectiveTitle,
+      contentReplacements: contentReplacementRecords
+    };
+    const titleInfo = title ? ` "${title}"` : "";
+    const resumeHint = `
+To resume the original: claude -r ${originalSessionId}`;
+    const successMessage = `Branched conversation${titleInfo}. You are now in the branch.${resumeHint}`;
+    if (context.resume) {
+      await context.resume(sessionId, forkLog, "fork");
+      onDone(successMessage, { display: "system" });
+    } else {
+      onDone(`Branched conversation${titleInfo}. Resume with: /resume ${sessionId}`);
+    }
+    return null;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error occurred";
+    onDone(`Failed to branch conversation: ${message}`);
+    return null;
+  }
+}
+var init_branch = __esm(() => {
+  init_state();
+  init_analytics();
+  init_json();
+  init_sessionStorage();
+  init_slowOperations();
+  init_stringUtils();
+});
+init_branch();
+
+export {
+  deriveFirstPrompt,
+  call
+};

package/dist/chunk-ctw5jwcd.js

@@ -0,0 +1,213 @@
+// @bun
+import {
+  init_sessionStoragePortable
+} from "./chunk-vratq94g.js";
+import {
+  getPlatform,
+  init_platform
+} from "./chunk-tjaqa99q.js";
+import {
+  init_memoize as init_memoize2,
+  memoizeWithLRU
+} from "./chunk-d18z9pna.js";
+import {
+  execSync_DEPRECATED,
+  init_execSyncWrapper
+} from "./chunk-vyc0rjyx.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-8bedvdm1.js";
+import {
+  getFsImplementation,
+  init_debug,
+  init_fsOperations,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-hqmz36b3.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/windowsPaths.ts
+import * as path from "path";
+import * as pathWin32 from "path/win32";
+function checkPathExists(path2) {
+  try {
+    execSync_DEPRECATED(`dir "${path2}"`, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findExecutable(executable) {
+  if (executable === "git") {
+    const defaultLocations = [
+      "C:\\Program Files\\Git\\cmd\\git.exe",
+      "C:\\Program Files (x86)\\Git\\cmd\\git.exe"
+    ];
+    for (const location of defaultLocations) {
+      if (checkPathExists(location)) {
+        return location;
+      }
+    }
+  }
+  try {
+    const result = execSync_DEPRECATED(`where.exe ${executable}`, {
+      stdio: "pipe",
+      encoding: "utf8"
+    }).trim();
+    const paths = result.split(`\r
+`).filter(Boolean);
+    const cwd = getCwd().toLowerCase();
+    for (const candidatePath of paths) {
+      const normalizedPath = path.resolve(candidatePath).toLowerCase();
+      const pathDir = path.dirname(normalizedPath).toLowerCase();
+      if (pathDir === cwd || normalizedPath.startsWith(cwd + path.sep)) {
+        logForDebugging(`Skipping potentially malicious executable in current directory: ${candidatePath}`);
+        continue;
+      }
+      return candidatePath;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function setShellIfWindows() {
+  if (getPlatform() === "windows") {
+    const gitBashPath = findGitBashPath();
+    process.env.SHELL = gitBashPath;
+    logForDebugging(`Using bash path: "${gitBashPath}"`);
+  }
+}
+var findGitBashPath, windowsPathToPosixPath, posixPathToWindowsPath;
+var init_windowsPaths = __esm(() => {
+  init_memoize();
+  init_cwd();
+  init_debug();
+  init_execSyncWrapper();
+  init_memoize2();
+  init_platform();
+  findGitBashPath = memoize_default(() => {
+    if (process.env.CLAUDE_CODE_GIT_BASH_PATH) {
+      if (checkPathExists(process.env.CLAUDE_CODE_GIT_BASH_PATH)) {
+        return process.env.CLAUDE_CODE_GIT_BASH_PATH;
+      }
+      console.error(`Claude Code was unable to find CLAUDE_CODE_GIT_BASH_PATH path "${process.env.CLAUDE_CODE_GIT_BASH_PATH}"`);
+      process.exit(1);
+    }
+    const gitPath = findExecutable("git");
+    if (gitPath) {
+      const bashPath = pathWin32.join(gitPath, "..", "..", "bin", "bash.exe");
+      if (checkPathExists(bashPath)) {
+        return bashPath;
+      }
+    }
+    console.error("Claude Code on Windows requires git-bash (https://git-scm.com/downloads/win). If installed but not in PATH, set environment variable pointing to your bash.exe, similar to: CLAUDE_CODE_GIT_BASH_PATH=C:\\Program Files\\Git\\bin\\bash.exe");
+    process.exit(1);
+  });
+  windowsPathToPosixPath = memoizeWithLRU((windowsPath) => {
+    if (windowsPath.startsWith("\\\\")) {
+      return windowsPath.replace(/\\/g, "/");
+    }
+    const match = windowsPath.match(/^([A-Za-z]):[/\\]/);
+    if (match) {
+      const driveLetter = match[1].toLowerCase();
+      return "/" + driveLetter + windowsPath.slice(2).replace(/\\/g, "/");
+    }
+    return windowsPath.replace(/\\/g, "/");
+  }, (p) => p, 500);
+  posixPathToWindowsPath = memoizeWithLRU((posixPath) => {
+    if (posixPath.startsWith("//")) {
+      return posixPath.replace(/\//g, "\\");
+    }
+    const cygdriveMatch = posixPath.match(/^\/cygdrive\/([A-Za-z])(\/|$)/);
+    if (cygdriveMatch) {
+      const driveLetter = cygdriveMatch[1].toUpperCase();
+      const rest = posixPath.slice(("/cygdrive/" + cygdriveMatch[1]).length);
+      return driveLetter + ":" + (rest || "\\").replace(/\//g, "\\");
+    }
+    const driveMatch = posixPath.match(/^\/([A-Za-z])(\/|$)/);
+    if (driveMatch) {
+      const driveLetter = driveMatch[1].toUpperCase();
+      const rest = posixPath.slice(2);
+      return driveLetter + ":" + (rest || "\\").replace(/\//g, "\\");
+    }
+    return posixPath.replace(/\//g, "\\");
+  }, (p) => p, 500);
+});
+
+// src/utils/path.ts
+import { homedir } from "os";
+import { dirname as dirname2, isAbsolute, join as join2, normalize, relative, resolve as resolve2 } from "path";
+function expandPath(path2, baseDir) {
+  const actualBaseDir = baseDir ?? getCwd() ?? getFsImplementation().cwd();
+  if (typeof path2 !== "string") {
+    throw new TypeError(`Path must be a string, received ${typeof path2}`);
+  }
+  if (typeof actualBaseDir !== "string") {
+    throw new TypeError(`Base directory must be a string, received ${typeof actualBaseDir}`);
+  }
+  if (path2.includes("\x00") || actualBaseDir.includes("\x00")) {
+    throw new Error("Path contains null bytes");
+  }
+  const trimmedPath = path2.trim();
+  if (!trimmedPath) {
+    return normalize(actualBaseDir).normalize("NFC");
+  }
+  if (trimmedPath === "~") {
+    return homedir().normalize("NFC");
+  }
+  if (trimmedPath.startsWith("~/")) {
+    return join2(homedir(), trimmedPath.slice(2)).normalize("NFC");
+  }
+  let processedPath = trimmedPath;
+  if (getPlatform() === "windows" && trimmedPath.match(/^\/[a-z]\//i)) {
+    try {
+      processedPath = posixPathToWindowsPath(trimmedPath);
+    } catch {
+      processedPath = trimmedPath;
+    }
+  }
+  if (isAbsolute(processedPath)) {
+    return normalize(processedPath).normalize("NFC");
+  }
+  return resolve2(actualBaseDir, processedPath).normalize("NFC");
+}
+function toRelativePath(absolutePath) {
+  const relativePath = relative(getCwd(), absolutePath);
+  return relativePath.startsWith("..") ? absolutePath : relativePath;
+}
+function getDirectoryForPath(path2) {
+  const absolutePath = expandPath(path2);
+  if (absolutePath.startsWith("\\\\") || absolutePath.startsWith("//")) {
+    return dirname2(absolutePath);
+  }
+  try {
+    const stats = getFsImplementation().statSync(absolutePath);
+    if (stats.isDirectory()) {
+      return absolutePath;
+    }
+  } catch {}
+  return dirname2(absolutePath);
+}
+function containsPathTraversal(path2) {
+  return /(?:^|[\\/])\.\.(?:[\\/]|$)/.test(path2);
+}
+function normalizePathForConfigKey(path2) {
+  const normalized = normalize(path2);
+  return normalized.replace(/\\/g, "/");
+}
+var init_path = __esm(() => {
+  init_cwd();
+  init_fsOperations();
+  init_platform();
+  init_windowsPaths();
+  init_sessionStoragePortable();
+});
+
+export { setShellIfWindows, findGitBashPath, windowsPathToPosixPath, posixPathToWindowsPath, init_windowsPaths, expandPath, toRelativePath, getDirectoryForPath, containsPathTraversal, normalizePathForConfigKey, init_path };

package/dist/chunk-cvy3vntc.js

@@ -0,0 +1,65 @@
+// @bun
+import {
+  init_slowOperations,
+  jsonParse,
+  jsonStringify
+} from "./chunk-nxsh6de2.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-xszk7n10.js";
+
+// src/bridge/workSecret.ts
+init_axios();
+init_slowOperations();
+function decodeWorkSecret(secret) {
+  const json = Buffer.from(secret, "base64url").toString("utf-8");
+  const parsed = jsonParse(json);
+  if (!parsed || typeof parsed !== "object" || !("version" in parsed) || parsed.version !== 1) {
+    throw new Error(`Unsupported work secret version: ${parsed && typeof parsed === "object" && "version" in parsed ? parsed.version : "unknown"}`);
+  }
+  const obj = parsed;
+  if (typeof obj.session_ingress_token !== "string" || obj.session_ingress_token.length === 0) {
+    throw new Error("Invalid work secret: missing or empty session_ingress_token");
+  }
+  if (typeof obj.api_base_url !== "string") {
+    throw new Error("Invalid work secret: missing api_base_url");
+  }
+  return parsed;
+}
+function buildSdkUrl(apiBaseUrl, sessionId) {
+  const isLocalhost = apiBaseUrl.includes("localhost") || apiBaseUrl.includes("127.0.0.1");
+  const protocol = isLocalhost ? "ws" : "wss";
+  const version = isLocalhost ? "v2" : "v1";
+  const host = apiBaseUrl.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+  return `${protocol}://${host}/${version}/session_ingress/ws/${sessionId}`;
+}
+function sameSessionId(a, b) {
+  if (a === b)
+    return true;
+  const aBody = a.slice(a.lastIndexOf("_") + 1);
+  const bBody = b.slice(b.lastIndexOf("_") + 1);
+  return aBody.length >= 4 && aBody === bBody;
+}
+function buildCCRv2SdkUrl(apiBaseUrl, sessionId) {
+  const base = apiBaseUrl.replace(/\/+$/, "");
+  return `${base}/v1/code/sessions/${sessionId}`;
+}
+async function registerWorker(sessionUrl, accessToken) {
+  const response = await axios_default.post(`${sessionUrl}/worker/register`, {}, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      "anthropic-version": "2023-06-01"
+    },
+    timeout: 1e4
+  });
+  const raw = response.data?.worker_epoch;
+  const epoch = typeof raw === "string" ? Number(raw) : raw;
+  if (typeof epoch !== "number" || !Number.isFinite(epoch) || !Number.isSafeInteger(epoch)) {
+    throw new Error(`registerWorker: invalid worker_epoch in response: ${jsonStringify(response.data)}`);
+  }
+  return epoch;
+}
+
+export { decodeWorkSecret, buildSdkUrl, sameSessionId, buildCCRv2SdkUrl, registerWorker };

package/dist/chunk-cwbzz504.js

@@ -0,0 +1,94 @@
+// @bun
+import {
+  CHANGELOG_URL,
+  fetchAndStoreChangelog,
+  getAllReleaseNotes,
+  getStoredChangelog,
+  init_releaseNotes
+} from "./chunk-frg83bfw.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-3f7rypmf.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-vratq94g.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-6kpbgc5w.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-tjaqa99q.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-w2z5pqd3.js";
+import"./chunk-7ymfj7m3.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-1eapde8a.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-1rvz0433.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-hrzerbfw.js";
+import"./chunk-d18z9pna.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-hjhc4cpt.js";
+import"./chunk-vyc0rjyx.js";
+import"./chunk-hx2tr4ep.js";
+import"./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/release-notes/release-notes.ts
+function formatReleaseNotes(notes) {
+  return notes.map(([version, notes2]) => {
+    const header = `Version ${version}:`;
+    const bulletPoints = notes2.map((note) => `\xB7 ${note}`).join(`
+`);
+    return `${header}
+${bulletPoints}`;
+  }).join(`
+
+`);
+}
+async function call() {
+  let freshNotes = [];
+  try {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout((rej) => rej(new Error("Timeout")), 500, reject);
+    });
+    await Promise.race([fetchAndStoreChangelog(), timeoutPromise]);
+    freshNotes = getAllReleaseNotes(await getStoredChangelog());
+  } catch {}
+  if (freshNotes.length > 0) {
+    return { type: "text", value: formatReleaseNotes(freshNotes) };
+  }
+  const cachedNotes = getAllReleaseNotes(await getStoredChangelog());
+  if (cachedNotes.length > 0) {
+    return { type: "text", value: formatReleaseNotes(cachedNotes) };
+  }
+  return {
+    type: "text",
+    value: `See the full changelog at: ${CHANGELOG_URL}`
+  };
+}
+var init_release_notes = __esm(() => {
+  init_releaseNotes();
+});
+init_release_notes();
+
+export {
+  call
+};

package/dist/chunk-cy2hswr1.js

@@ -0,0 +1,15 @@
+// @bun
+import {
+  EXTERNAL_PERMISSION_MODES,
+  INTERNAL_PERMISSION_MODES,
+  PERMISSION_MODES,
+  init_permissions
+} from "./chunk-6kpbgc5w.js";
+import"./chunk-qp2qdcda.js";
+init_permissions();
+
+export {
+  PERMISSION_MODES,
+  INTERNAL_PERMISSION_MODES,
+  EXTERNAL_PERMISSION_MODES
+};