@linghun/tui 0.1.0

package/dist/chunk-YTQFOZRZ.js

@@ -0,0 +1,110 @@
+// src/prompt-command-runtime.ts
+var PROMPT_COMMANDS = {
+  "/commit": {
+    name: "/commit",
+    promptCommand: true,
+    description: "Ask the model to review the current git diff and prepare a safe commit plan.",
+    buildPrompt: (args, language) => createPromptCommandText(
+      language,
+      "/commit",
+      args,
+      [
+        "Inspect git status and diff before making any claim.",
+        "Summarize changed files and risk.",
+        "Suggest a concise commit message.",
+        "Only run git commit if the user explicitly confirms and permissions allow it."
+      ]
+    )
+  },
+  "/init": {
+    name: "/init",
+    promptCommand: true,
+    description: "Ask the model to explore the project and draft Linghun project instructions.",
+    buildPrompt: (args, language) => createPromptCommandText(
+      language,
+      "/init",
+      args,
+      [
+        "Ask for scope if the target instructions file or project boundary is unclear.",
+        "Explore the repository structure with read/search tools.",
+        "Draft minimal project instructions aligned with existing style.",
+        "Write files only after evidence and permission approval.",
+        "Summarize created or updated files and validation gaps."
+      ]
+    )
+  },
+  "/security-review": {
+    name: "/security-review",
+    promptCommand: true,
+    description: "Ask the model to review git diff for security risks and produce a report.",
+    buildPrompt: (args, language) => createPromptCommandText(
+      language,
+      "/security-review",
+      args,
+      [
+        "Collect git diff and relevant changed files.",
+        "Check for SQL injection, XSS, RCE, path traversal, auth bypass, secret leakage, and unsafe deserialization.",
+        "Separate confirmed findings from false positives and uncertain risks.",
+        "Produce a Markdown report in the answer unless the user explicitly asks to write a file."
+      ]
+    )
+  },
+  "/commit-push-pr": {
+    name: "/commit-push-pr",
+    promptCommand: true,
+    description: "Ask the model to guide branch, commit, push, and PR creation.",
+    buildPrompt: (args, language) => createPromptCommandText(
+      language,
+      "/commit-push-pr",
+      args,
+      [
+        "Inspect git status, branch, remotes, and available gh CLI before acting.",
+        "Create or reuse a safe branch only with user approval.",
+        "Commit, push, and create a PR only through explicit tool calls and permission gates.",
+        "Use heredoc or file-based bodies for long commit/PR text to avoid shell quoting mistakes.",
+        "Report exact commands run and any blocked step."
+      ]
+    )
+  },
+  "/init-verifiers": {
+    name: "/init-verifiers",
+    promptCommand: true,
+    description: "Ask the model to design project-specific verification helpers.",
+    buildPrompt: (args, language) => createPromptCommandText(
+      language,
+      "/init-verifiers",
+      args,
+      [
+        "Detect the project language, package manager, and existing verification scripts.",
+        "Prefer existing scripts before proposing new tools.",
+        "Ask before installing dependencies or changing config.",
+        "If creating verifier instructions, keep them minimal and project-specific.",
+        "Summarize runnable verification commands and remaining gaps."
+      ]
+    )
+  }
+};
+function findPromptCommand(command) {
+  return PROMPT_COMMANDS[command];
+}
+function buildPromptCommandUserText(command, args, language) {
+  return PROMPT_COMMANDS[command]?.buildPrompt(args, language);
+}
+function createPromptCommandText(language, command, args, steps) {
+  const userArgs = args.join(" ").trim() || "(none)";
+  const header = language === "en-US" ? `PromptCommand ${command}: execute through Linghun's normal model/tool loop.` : `PromptCommand ${command}\uFF1A\u901A\u8FC7 Linghun \u73B0\u6709\u6A21\u578B/\u5DE5\u5177\u4E3B\u5FAA\u73AF\u6267\u884C\u3002`;
+  const constraints = language === "en-US" ? "Do not bypass Start Gate, Plan, permissions, evidence, or final-answer verification. Do not claim actions were executed until tool results prove them." : "\u4E0D\u5F97\u7ED5\u8FC7 Start Gate\u3001Plan\u3001\u6743\u9650\u3001\u8BC1\u636E\u6216\u6700\u7EC8\u56DE\u7B54\u6821\u9A8C\u3002\u6CA1\u6709\u5DE5\u5177\u7ED3\u679C\u8BC1\u660E\u524D\uFF0C\u4E0D\u5F97\u58F0\u79F0\u5DF2\u6267\u884C\u52A8\u4F5C\u3002";
+  return [
+    header,
+    `CommandArgs=${userArgs}`,
+    constraints,
+    "Steps:",
+    ...steps.map((step, index) => `${index + 1}. ${step}`)
+  ].join("\n");
+}
+
+export {
+  PROMPT_COMMANDS,
+  findPromptCommand,
+  buildPromptCommandUserText
+};

package/dist/chunk-ZJK25VFP.js

@@ -0,0 +1,506 @@
+// src/workspace-reference-cache.ts
+import { createHash } from "crypto";
+import { lstat, open, opendir, readdir, stat } from "fs/promises";
+import { join } from "path";
+var DEFAULT_FILE_HASH_BYTES = 256 * 1024;
+var DEFAULT_IGNORE_FILE_BYTES = 64 * 1024;
+var DEFAULT_TOP_LEVEL_ENTRY_LIMIT = 80;
+var HARD_SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".linghun/cache",
+  ".next",
+  ".turbo",
+  ".cache",
+  "build",
+  "cache",
+  "coverage",
+  "dist",
+  "node_modules",
+  "out",
+  "target"
+]);
+var IGNORE_FILES = [".linghunignore", ".cbmignore", ".gitignore"];
+var DEFAULT_WATCHED_FILES = [
+  "README.md",
+  "package.json",
+  "LINGHUN.md",
+  "CLAUDE.md",
+  ".linghun/settings.json",
+  ".linghunignore",
+  ".cbmignore",
+  ".gitignore"
+];
+var DEFAULT_WATCHED_DIRECTORIES = [".", ".linghun"];
+async function getWorkspaceReferenceSnapshot(cache, input, scan = scanWorkspaceReference) {
+  const inputHash = stableHash({
+    projectPath: input.projectPath,
+    dimensions: input.dimensions,
+    runtimeStatus: input.runtimeStatus,
+    toolCapabilitySummary: input.toolCapabilitySummary,
+    evidenceRefs: input.evidenceRefs ?? [],
+    logRefs: input.logRefs ?? [],
+    watchedFiles: input.watchedFiles ?? DEFAULT_WATCHED_FILES,
+    watchedDirectories: input.watchedDirectories ?? DEFAULT_WATCHED_DIRECTORIES,
+    fileHashBytes: input.fileHashBytes ?? DEFAULT_FILE_HASH_BYTES
+  });
+  if (cache._pendingProbe && cache._pendingProbeInputHash === inputHash) {
+    return cache._pendingProbe;
+  }
+  const promise = _getWorkspaceReferenceSnapshotInner(cache, input, scan);
+  cache._pendingProbe = promise;
+  cache._pendingProbeInputHash = inputHash;
+  try {
+    return await promise;
+  } finally {
+    if (cache._pendingProbe === promise) {
+      cache._pendingProbe = void 0;
+      cache._pendingProbeInputHash = void 0;
+    }
+  }
+}
+async function _getWorkspaceReferenceSnapshotInner(cache, input, scan) {
+  try {
+    if (cache.latest) {
+      const probe = await probeWorkspaceReference(input);
+      if (workspaceReferenceProbeMatches(cache.latest, input.dimensions, probe)) {
+        cache.hits += 1;
+        return { ...cache.latest, source: "hit", changedKeys: [] };
+      }
+    }
+    const scanned = await scan(input);
+    const key = workspaceReferenceKey(scanned);
+    const previous = cache.latest;
+    if (previous?.key === key) {
+      cache.hits += 1;
+      return { ...previous, source: "hit", changedKeys: [] };
+    }
+    const changedKeys = diffWorkspaceReference(previous, key, scanned);
+    const snapshot = {
+      key,
+      source: previous ? "stale" : "miss",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      changedKeys,
+      dimensions: scanned.dimensions,
+      files: scanned.files,
+      directories: scanned.directories,
+      runtimeStatus: scanned.runtimeStatus,
+      toolCapabilitySummary: truncateText(input.toolCapabilitySummary, 2e3),
+      evidenceRefs: sanitizeRefs(scanned.evidenceRefs),
+      logRefs: sanitizeRefs(scanned.logRefs),
+      workspaceSnapshot: attachWorkspaceSnapshotChangedSummary(
+        scanned.workspaceSnapshot,
+        previous?.workspaceSnapshot
+      )
+    };
+    cache.latest = snapshot;
+    cache.misses += 1;
+    return snapshot;
+  } catch (error) {
+    cache.failures += 1;
+    const hasPrev = Boolean(cache.latest);
+    const fallbackSource = hasPrev ? "fallback-stale" : "fallback-empty";
+    return {
+      key: cache.latest?.key ?? "fallback",
+      source: fallbackSource,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      changedKeys: ["workspaceReferenceUnavailable", fallbackSource],
+      dimensions: input.dimensions,
+      files: cache.latest?.files ?? [],
+      directories: cache.latest?.directories ?? [],
+      runtimeStatus: input.runtimeStatus,
+      toolCapabilitySummary: truncateText(input.toolCapabilitySummary, 2e3),
+      evidenceRefs: sanitizeRefs(input.evidenceRefs ?? []),
+      logRefs: sanitizeRefs(input.logRefs ?? []),
+      workspaceSnapshot: cache.latest?.workspaceSnapshot,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function createWorkspaceReferenceCache() {
+  return { hits: 0, misses: 0, failures: 0 };
+}
+function workspaceReferenceHash(snapshot) {
+  if (!snapshot) {
+    return stableHash("none");
+  }
+  return stableHash({
+    key: snapshot.key,
+    changedKeys: snapshot.changedKeys,
+    source: snapshot.source
+  });
+}
+function isFallbackWorkspaceReferenceSnapshot(snapshot) {
+  if (!snapshot) return false;
+  return snapshot.source === "fallback" || snapshot.source === "fallback-stale" || snapshot.source === "fallback-empty";
+}
+async function scanWorkspaceReference(input) {
+  const watchedFiles = input.watchedFiles ?? DEFAULT_WATCHED_FILES;
+  const watchedDirectories = input.watchedDirectories ?? DEFAULT_WATCHED_DIRECTORIES;
+  const fileHashBytes = input.fileHashBytes ?? DEFAULT_FILE_HASH_BYTES;
+  const [files, directories, workspaceSnapshot] = await Promise.all([
+    Promise.all(watchedFiles.map((path) => summarizeFile(input.projectPath, path, fileHashBytes))),
+    Promise.all(watchedDirectories.map((path) => summarizeDirectory(input.projectPath, path))),
+    summarizeWorkspaceSnapshotLite(input.projectPath, fileHashBytes)
+  ]);
+  return {
+    dimensions: input.dimensions,
+    files,
+    directories,
+    runtimeStatus: input.runtimeStatus,
+    toolCapabilitySummary: truncateText(input.toolCapabilitySummary, 2e3),
+    evidenceRefs: sanitizeRefs(input.evidenceRefs ?? []),
+    logRefs: sanitizeRefs(input.logRefs ?? []),
+    workspaceSnapshot
+  };
+}
+async function probeWorkspaceReference(input) {
+  const watchedFiles = input.watchedFiles ?? DEFAULT_WATCHED_FILES;
+  const watchedDirectories = input.watchedDirectories ?? DEFAULT_WATCHED_DIRECTORIES;
+  const fileHashBytes = input.fileHashBytes ?? DEFAULT_FILE_HASH_BYTES;
+  const [files, directories, workspaceSnapshot] = await Promise.all([
+    Promise.all(watchedFiles.map((path) => summarizeFile(input.projectPath, path, fileHashBytes))),
+    Promise.all(watchedDirectories.map((path) => summarizeDirectory(input.projectPath, path))),
+    summarizeWorkspaceSnapshotLite(input.projectPath, fileHashBytes)
+  ]);
+  return { files, directories, workspaceSnapshot };
+}
+function workspaceReferenceProbeMatches(previous, dimensions, probe) {
+  return stableHash(previous.dimensions) === stableHash(dimensions) && stableHash(previous.files.map((file) => fileStatKey(file))) === stableHash(probe.files.map((file) => fileStatKey(file))) && stableHash(previous.directories) === stableHash(probe.directories) && (!previous.workspaceSnapshot || stableHash(stripWorkspaceSnapshotChangedSummary(previous.workspaceSnapshot)) === stableHash(stripWorkspaceSnapshotChangedSummary(probe.workspaceSnapshot)));
+}
+function fileStatKey(file) {
+  return {
+    path: file.path,
+    exists: file.exists,
+    readable: file.readable,
+    size: file.size,
+    mtimeMs: file.mtimeMs
+  };
+}
+async function summarizeFile(projectPath, relativePath, maxHashBytes) {
+  const normalized = normalizeRelativePath(relativePath);
+  const absolutePath = join(projectPath, normalized);
+  try {
+    const fileStat = await stat(absolutePath);
+    if (!fileStat.isFile()) {
+      return missingFile(normalized);
+    }
+    const bounded = await readFilePrefix(absolutePath, fileStat.size, maxHashBytes);
+    const hash = stableHash({
+      size: fileStat.size,
+      mtimeMs: Math.trunc(fileStat.mtimeMs),
+      contentHash: sha256(bounded),
+      truncated: fileStat.size > bounded.length
+    });
+    return {
+      path: normalized,
+      exists: true,
+      readable: true,
+      size: fileStat.size,
+      mtimeMs: Math.trunc(fileStat.mtimeMs),
+      hash
+    };
+  } catch {
+    return missingFile(normalized);
+  }
+}
+function missingFile(path) {
+  return { path, exists: false, readable: false, size: 0, mtimeMs: 0, hash: stableHash("missing") };
+}
+async function summarizeDirectory(projectPath, relativePath) {
+  const normalized = normalizeRelativePath(relativePath);
+  try {
+    const entries = await readdir(join(projectPath, normalized), { withFileTypes: true });
+    const files = entries.filter((entry) => entry.isFile()).length;
+    const directories = entries.filter((entry) => entry.isDirectory()).length;
+    const entryHash = stableHash(
+      entries.map((entry) => ({
+        name: entry.name,
+        kind: entry.isDirectory() ? "dir" : entry.isFile() ? "file" : "other"
+      })).sort((a, b) => `${a.kind}:${a.name}`.localeCompare(`${b.kind}:${b.name}`))
+    );
+    return { path: normalized, readable: true, files, directories, entryHash };
+  } catch {
+    return {
+      path: normalized,
+      readable: false,
+      files: 0,
+      directories: 0,
+      entryHash: stableHash("missing")
+    };
+  }
+}
+function workspaceReferenceKey(scan) {
+  return stableHash({
+    dimensions: scan.dimensions,
+    files: scan.files,
+    directories: scan.directories,
+    workspaceSnapshot: stripWorkspaceSnapshotChangedSummary(scan.workspaceSnapshot),
+    runtimeStatus: scan.runtimeStatus,
+    toolCapabilitySummary: scan.toolCapabilitySummary,
+    evidenceRefs: scan.evidenceRefs,
+    logRefs: scan.logRefs
+  });
+}
+function diffWorkspaceReference(previous, key, scan) {
+  if (!previous) {
+    return [];
+  }
+  const changed = /* @__PURE__ */ new Set();
+  if (previous.key !== key) changed.add("workspaceReferenceHash");
+  for (const [name, value] of Object.entries(scan.dimensions)) {
+    if (previous.dimensions[name] !== value) {
+      changed.add(name);
+    }
+  }
+  if (stableHash(previous.files) !== stableHash(scan.files)) changed.add("fileStatHash");
+  if (stableHash(previous.directories) !== stableHash(scan.directories)) {
+    changed.add("directorySummaryHash");
+  }
+  if (stableHash(stripWorkspaceSnapshotChangedSummary(previous.workspaceSnapshot)) !== stableHash(stripWorkspaceSnapshotChangedSummary(scan.workspaceSnapshot))) {
+    changed.add("workspaceSnapshotHash");
+  }
+  return [...changed].sort((a, b) => a.localeCompare(b));
+}
+async function summarizeWorkspaceSnapshotLite(projectPath, fileHashBytes) {
+  const entries = [];
+  const counts = { files: 0, directories: 0, symlinks: 0, other: 0, ignored: 0, storedEntries: 0 };
+  let partial = false;
+  const ignoreSources = await readIgnoreSources(projectPath);
+  const directory = await opendir(projectPath);
+  try {
+    for await (const entry of directory) {
+      const relativePath = normalizeRelativePath(entry.name);
+      const ignoredReason = getIgnoredReason(relativePath, entry.name, ignoreSources);
+      if (ignoredReason) {
+        counts.ignored += 1;
+        if (entries.length >= DEFAULT_TOP_LEVEL_ENTRY_LIMIT) {
+          partial = true;
+          continue;
+        }
+        entries.push({
+          path: relativePath,
+          kind: entry.isDirectory() ? "directory" : entry.isFile() ? "file" : "other",
+          size: 0,
+          mtimeMs: 0,
+          ignoredReason
+        });
+        continue;
+      }
+      if (entries.length >= DEFAULT_TOP_LEVEL_ENTRY_LIMIT) {
+        partial = true;
+        continue;
+      }
+      const absolutePath = join(projectPath, entry.name);
+      const entryStat = await lstat(absolutePath);
+      const kind = entryStat.isSymbolicLink() ? "symlink" : entryStat.isDirectory() ? "directory" : entryStat.isFile() ? "file" : "other";
+      incrementWorkspaceSnapshotCount(counts, kind);
+      entries.push({
+        path: relativePath,
+        kind,
+        size: entryStat.size,
+        mtimeMs: Math.trunc(entryStat.mtimeMs),
+        hashPrefix: kind === "file" ? await hashFilePrefix(absolutePath, entryStat.size, fileHashBytes) : void 0
+      });
+    }
+  } finally {
+    await directory.close().catch(() => void 0);
+  }
+  counts.storedEntries = entries.length;
+  return {
+    schemaVersion: 1,
+    root: ".",
+    bounded: true,
+    partial,
+    limits: { topLevelEntryLimit: DEFAULT_TOP_LEVEL_ENTRY_LIMIT, fileHashBytes },
+    counts,
+    ignoreSources: ignoreSources.map(({ path, readable, hashPrefix }) => ({
+      path,
+      readable,
+      hashPrefix
+    })),
+    entries: entries.sort((a, b) => a.path.localeCompare(b.path))
+  };
+}
+async function readIgnoreSources(projectPath) {
+  return Promise.all(
+    IGNORE_FILES.map(async (path) => {
+      const absolutePath = join(projectPath, path);
+      try {
+        const fileStat = await stat(absolutePath);
+        if (!fileStat.isFile()) {
+          return { path, readable: false, patterns: [] };
+        }
+        const content = await readFilePrefix(
+          absolutePath,
+          fileStat.size,
+          DEFAULT_IGNORE_FILE_BYTES
+        );
+        return {
+          path,
+          readable: true,
+          patterns: parseIgnorePatterns(content.toString("utf8")),
+          hashPrefix: sha256(content).slice(0, 12)
+        };
+      } catch {
+        return { path, readable: false, patterns: [] };
+      }
+    })
+  );
+}
+function getIgnoredReason(relativePath, name, ignoreSources) {
+  if (HARD_SKIP_DIRS.has(relativePath) || HARD_SKIP_DIRS.has(name)) {
+    return `hard-skip:${name}`;
+  }
+  for (const source of ignoreSources) {
+    if (!source.readable) {
+      continue;
+    }
+    const matched = source.patterns.find(
+      (pattern) => ignorePatternMatches(pattern, relativePath, name)
+    );
+    if (matched) {
+      return `${source.path}:${matched}`;
+    }
+  }
+  return void 0;
+}
+function parseIgnorePatterns(content) {
+  return content.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#") && !line.startsWith("!")).slice(0, 200);
+}
+function ignorePatternMatches(pattern, relativePath, name) {
+  const normalized = normalizeRelativePath(pattern).replace(/^\//, "");
+  const directoryPattern = pattern.endsWith("/") ? normalized.replace(/\/$/, "") : normalized;
+  if (!directoryPattern) {
+    return false;
+  }
+  const path = normalizeRelativePath(relativePath);
+  if (!directoryPattern.includes("*")) {
+    return path === directoryPattern || name === directoryPattern || path.startsWith(`${directoryPattern}/`);
+  }
+  const regex = globPatternToRegExp(directoryPattern);
+  return regex.test(path) || regex.test(name);
+}
+function globPatternToRegExp(pattern) {
+  let source = "";
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === "*") {
+      const next = pattern[index + 1];
+      if (next === "*") {
+        source += ".*";
+        index += 1;
+      } else {
+        source += "[^/]*";
+      }
+      continue;
+    }
+    source += escapeRegExp(char ?? "");
+  }
+  return new RegExp(`^(?:${source})(?:/.*)?$`, "u");
+}
+function escapeRegExp(value) {
+  return value.replace(/[\\^$+?.()|[\]{}]/gu, "\\$&");
+}
+function incrementWorkspaceSnapshotCount(counts, kind) {
+  if (kind === "file") counts.files += 1;
+  if (kind === "directory") counts.directories += 1;
+  if (kind === "symlink") counts.symlinks += 1;
+  if (kind === "other") counts.other += 1;
+}
+function attachWorkspaceSnapshotChangedSummary(current, previous) {
+  if (!current) {
+    return void 0;
+  }
+  return {
+    ...current,
+    changedSummary: diffWorkspaceSnapshotLite(previous, current)
+  };
+}
+function diffWorkspaceSnapshotLite(previous, current) {
+  if (!previous) {
+    return { added: 0, modified: 0, deleted: 0, changedKeys: [] };
+  }
+  const previousEntries = new Map(previous.entries.map((entry) => [entry.path, stableHash(entry)]));
+  const currentEntries = new Map(current.entries.map((entry) => [entry.path, stableHash(entry)]));
+  let added = 0;
+  let modified = 0;
+  let deleted = 0;
+  for (const [path, hash] of currentEntries) {
+    const previousHash = previousEntries.get(path);
+    if (!previousHash) {
+      added += 1;
+      continue;
+    }
+    if (previousHash !== hash) {
+      modified += 1;
+    }
+  }
+  for (const path of previousEntries.keys()) {
+    if (!currentEntries.has(path)) {
+      deleted += 1;
+    }
+  }
+  const changedKeys = [
+    ...added > 0 ? ["workspaceSnapshotAdded"] : [],
+    ...modified > 0 ? ["workspaceSnapshotModified"] : [],
+    ...deleted > 0 ? ["workspaceSnapshotDeleted"] : []
+  ];
+  return { added, modified, deleted, changedKeys };
+}
+function stripWorkspaceSnapshotChangedSummary(snapshot) {
+  if (!snapshot) {
+    return void 0;
+  }
+  const { changedSummary: _changedSummary, ...rest } = snapshot;
+  return rest;
+}
+async function hashFilePrefix(absolutePath, size, maxBytes) {
+  return sha256(await readFilePrefix(absolutePath, size, maxBytes)).slice(0, 12);
+}
+async function readFilePrefix(absolutePath, size, maxBytes) {
+  const bytesToRead = Math.max(0, Math.min(size, maxBytes));
+  if (bytesToRead === 0) {
+    return Buffer.alloc(0);
+  }
+  const handle = await open(absolutePath, "r");
+  try {
+    const buffer = Buffer.alloc(bytesToRead);
+    const { bytesRead } = await handle.read(buffer, 0, bytesToRead, 0);
+    return buffer.subarray(0, bytesRead);
+  } finally {
+    await handle.close();
+  }
+}
+function sanitizeRefs(refs) {
+  return refs.map((ref) => truncateText(ref.replace(/\s+/g, " "), 240)).slice(0, 20);
+}
+function normalizeRelativePath(path) {
+  const normalized = path.replaceAll("\\", "/").replace(/^\.\//, "").replace(/\/$/, "");
+  return normalized || ".";
+}
+function truncateText(text, max) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, Math.max(0, max - 1))}\u2026`;
+}
+function stableHash(value) {
+  return sha256(Buffer.from(stableStringify(value), "utf8")).slice(0, 12);
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${key}:${stableStringify(item)}`).join(",")}}`;
+  }
+  return JSON.stringify(value) ?? String(value);
+}
+
+export {
+  getWorkspaceReferenceSnapshot,
+  createWorkspaceReferenceCache,
+  workspaceReferenceHash,
+  isFallbackWorkspaceReferenceSnapshot
+};