@surething/cockpit 1.0.213 → 1.0.215

package/bin/cock.mjs

@@ -21,6 +21,7 @@ Commands:
   cockpit <path>                 Start server, open specified directory
   browser <id> <action>          Control browser bubbles
   terminal <id> <action>         Control terminal bubbles
+  codegraph <subcmd> [...]       Query the project code graph (search/risk/affected/...)
   update                         Update to latest version
 
 Options:
@@ -93,6 +94,13 @@ if (process.argv[2] === 'terminal') {
   await flushAndExit(0);
 }
 
+if (process.argv[2] === 'codegraph') {
+  process.argv.splice(2, 1);
+  const mod = await import('./cock-codegraph.mjs');
+  await mod.done;
+  await flushAndExit(0);
+}
+
 if (process.argv[2] === 'update') {
   console.log('Updating @surething/cockpit...');
   const result = spawnSync('npm', ['install', '-g', '@surething/cockpit@latest'], { stdio: 'inherit' });
@@ -110,7 +118,7 @@ if (process.argv[2] === 'update') {
 const { existsSync, mkdirSync } = await import('fs');
 const { homedir } = await import('os');
 
-const knownCommands = new Set(['browser', 'terminal', 'update', 'help']);
+const knownCommands = new Set(['browser', 'terminal', 'update', 'help', 'codegraph']);
 const arg = process.argv[2];
 let projectDir = null;
 

package/bin/cockpit-dev.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+// cockpit-dev: dev-mode entry. Sets dev env + delegates to cock.mjs which
+// holds the shared subcommand dispatcher. The prod entry binaries are
+// `cockpit` (recommended) and its short alias `cock` — there is NO short
+// `cock-dev` alias by design; dev mode uses the full name only.
+process.env.COCKPIT_ENV = 'dev';
+process.env.COCKPIT_PORT = process.env.COCKPIT_PORT || '3456';
+await import('./cock.mjs');

package/bin/setup-dev.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * Selective symlink for `cockpit-dev` — installs ONLY the dev binary as
+ * a live symlink to local source, without touching the global `cockpit`
+ * / `cock` binaries which come from `npm install -g @surething/cockpit`.
+ *
+ * Why not `npm link`:
+ *   `npm link` is all-or-nothing — it overrides ALL package.json `bin`
+ *   entries (cockpit, cock, cockpit-dev) with symlinks to local source.
+ *   That means your prod `cockpit` becomes the dev source too, and any
+ *   broken commit in the repo immediately breaks production usage. The
+ *   `unlink` / `install -g` dance to recover is friction.
+ *
+ *   This script avoids that by symlinking JUST `cockpit-dev`. Result:
+ *     - `cockpit`      → unchanged (npm-installed, stable, follows releases)
+ *     - `cock`         → unchanged (npm-installed, prod alias)
+ *     - `cockpit-dev`  → symlink → /<repo>/bin/cockpit-dev.mjs (live)
+ *
+ *   You never need to "unlink"; the symlink coexists with the npm install
+ *   peacefully and `npm i -g @surething/cockpit@latest` to upgrade prod
+ *   leaves the dev symlink untouched.
+ *
+ * Idempotent: replaces an existing symlink/file if present.
+ *
+ * Run from the cockpit repo root: `npm run setup-dev`
+ */
+import { existsSync, lstatSync, unlinkSync, symlinkSync, chmodSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(SCRIPT_DIR, '..');
+const SOURCE = resolve(REPO_ROOT, 'bin/cockpit-dev.mjs');
+
+if (!existsSync(SOURCE)) {
+  console.error(`✗ Source not found: ${SOURCE}`);
+  console.error(`  Are you running from the cockpit repo? cwd=${process.cwd()}`);
+  process.exit(1);
+}
+
+// Resolve global npm bin dir.
+let prefix;
+try {
+  prefix = execSync('npm config get prefix', { encoding: 'utf8' }).trim();
+} catch (err) {
+  console.error('✗ Failed to resolve npm prefix:', err?.message);
+  process.exit(1);
+}
+const TARGET = resolve(prefix, 'bin/cockpit-dev');
+
+// Ensure source is executable.
+try {
+  chmodSync(SOURCE, 0o755);
+} catch {
+  /* non-fatal */
+}
+
+// Replace existing symlink/file if any.
+if (existsSync(TARGET) || (() => { try { return lstatSync(TARGET).isSymbolicLink(); } catch { return false; } })()) {
+  try {
+    unlinkSync(TARGET);
+  } catch (err) {
+    console.error(`✗ Could not remove existing ${TARGET}:`, err?.message);
+    console.error(`  You may need: sudo rm ${TARGET}`);
+    process.exit(1);
+  }
+}
+
+try {
+  symlinkSync(SOURCE, TARGET, 'file');
+} catch (err) {
+  if (err?.code === 'EACCES' || err?.code === 'EPERM') {
+    console.error(`✗ Permission denied creating ${TARGET}`);
+    console.error(`  Either: sudo ln -sf ${SOURCE} ${TARGET}`);
+    console.error(`  Or:     configure npm prefix to a user-writable dir`);
+    console.error(`           (e.g. npm config set prefix ~/.npm-global)`);
+    process.exit(1);
+  }
+  console.error(`✗ Failed:`, err?.message);
+  process.exit(1);
+}
+
+console.log(`✓ Linked ${TARGET}`);
+console.log(`           → ${SOURCE}`);
+console.log('');
+console.log('Now usable:');
+console.log('  cockpit-dev --version              # should report current local version');
+console.log('  cockpit-dev codegraph search foo   # talks to dev server on port 3456');
+console.log('');
+console.log('Edits to bin/*.mjs are live (no rerun needed).');
+console.log('Prod `cockpit` / `cock` are untouched — they still come from your npm install.');

package/dist/cache-GIQJA4HL.mjs

@@ -0,0 +1,502 @@
+import "./chunk-7P6ASYW6.mjs";
+
+// packages/feature/explorer/src/server/codeMap/analytics/types.ts
+function makeNodeId(filePath, qualifiedName) {
+  return `${filePath}::${qualifiedName}`;
+}
+
+// packages/feature/explorer/src/server/codeMap/analytics/graph.ts
+var FILE_NODE_QNAME = "__file__";
+function fileNodeId(filePath) {
+  return makeNodeId(filePath, FILE_NODE_QNAME);
+}
+function buildAnalyticsGraph(index, version) {
+  const nodes = /* @__PURE__ */ new Map();
+  const out = /* @__PURE__ */ new Map();
+  const inn = /* @__PURE__ */ new Map();
+  const pushEdge = (map, from, edge) => {
+    let list = map.get(from);
+    if (!list) {
+      list = [];
+      map.set(from, list);
+    }
+    list.push(edge);
+  };
+  for (const [filePath, file] of index.files) {
+    for (const sym of file.flatSymbols) {
+      const id = makeNodeId(filePath, sym.qualifiedName);
+      if (!nodes.has(id)) {
+        nodes.set(id, {
+          filePath,
+          qualifiedName: sym.qualifiedName,
+          name: sym.name,
+          kind: sym.kind,
+          startLine: sym.startLine,
+          endLine: sym.endLine
+        });
+      }
+    }
+    const fId = fileNodeId(filePath);
+    if (!nodes.has(fId)) {
+      nodes.set(fId, {
+        filePath,
+        qualifiedName: FILE_NODE_QNAME,
+        name: basename(filePath),
+        // We deliberately use 'unknown' kind — SymbolKind doesn't have
+        // 'file' and we don't want to expand the union for an internal
+        // virtual node.
+        kind: "unknown",
+        startLine: 0,
+        endLine: 0
+      });
+    }
+  }
+  for (const [filePath, file] of index.files) {
+    for (const call of file.intraCalls) {
+      const from = makeNodeId(filePath, call.from);
+      const to = makeNodeId(filePath, call.to);
+      if (!nodes.has(from) || !nodes.has(to)) continue;
+      const weight = Math.max(1, call.lines.length);
+      pushEdge(out, from, { target: to, edgeType: "intraCall", weight });
+      pushEdge(inn, to, { target: from, edgeType: "intraCall", weight });
+    }
+  }
+  for (const [filePath, file] of index.files) {
+    for (const call of file.outgoingCalls) {
+      const from = makeNodeId(filePath, call.from);
+      const to = makeNodeId(call.to.filePath, call.to.qualifiedName);
+      if (!nodes.has(from) || !nodes.has(to)) continue;
+      const weight = Math.max(1, call.lines.length);
+      pushEdge(out, from, { target: to, edgeType: "crossCall", weight });
+      pushEdge(inn, to, { target: from, edgeType: "crossCall", weight });
+    }
+  }
+  for (const [filePath, file] of index.files) {
+    const fromFNode = fileNodeId(filePath);
+    for (const importedFile of file.importedFiles) {
+      const toFNode = fileNodeId(importedFile);
+      if (!nodes.has(toFNode)) continue;
+      pushEdge(out, fromFNode, {
+        target: toFNode,
+        edgeType: "import",
+        weight: 1
+      });
+      pushEdge(inn, toFNode, {
+        target: fromFNode,
+        edgeType: "import",
+        weight: 1
+      });
+    }
+  }
+  for (const [filePath, file] of index.files) {
+    const fNode = fileNodeId(filePath);
+    const symbols = file.flatSymbols;
+    if (symbols.length === 0) continue;
+    const outflowWeight = 1 / symbols.length;
+    for (const sym of symbols) {
+      const symId = makeNodeId(filePath, sym.qualifiedName);
+      if (!nodes.has(symId)) continue;
+      pushEdge(out, symId, {
+        target: fNode,
+        edgeType: "import",
+        // reuse type tag (no need for a new one)
+        weight: 1
+      });
+      pushEdge(inn, fNode, {
+        target: symId,
+        edgeType: "import",
+        weight: 1
+      });
+      pushEdge(out, fNode, {
+        target: symId,
+        edgeType: "import",
+        weight: outflowWeight
+      });
+      pushEdge(inn, symId, {
+        target: fNode,
+        edgeType: "import",
+        weight: outflowWeight
+      });
+    }
+  }
+  return {
+    cwd: index.cwd,
+    version,
+    nodes,
+    out,
+    in: inn
+  };
+}
+function basename(p) {
+  const i = p.lastIndexOf("/");
+  return i < 0 ? p : p.slice(i + 1);
+}
+
+// packages/feature/explorer/src/server/codeMap/analytics/pagerank.ts
+function buildOutSumCache(graph) {
+  const outSum = /* @__PURE__ */ new Map();
+  const dangling = [];
+  for (const id of graph.nodes.keys()) {
+    const edges = graph.out.get(id);
+    if (!edges || edges.length === 0) {
+      outSum.set(id, 0);
+      dangling.push(id);
+      continue;
+    }
+    let s = 0;
+    for (const e of edges) s += e.weight;
+    outSum.set(id, s);
+  }
+  return { outSum, dangling };
+}
+function iterate(graph, resetVec, damping, maxIter, tol, cache2) {
+  const n = graph.nodes.size;
+  if (n === 0) return /* @__PURE__ */ new Map();
+  let rank = /* @__PURE__ */ new Map();
+  for (const id of graph.nodes.keys()) {
+    rank.set(id, resetVec.get(id) ?? 0);
+  }
+  for (let iter = 0; iter < maxIter; iter++) {
+    const next = /* @__PURE__ */ new Map();
+    for (const id of graph.nodes.keys()) {
+      next.set(id, (1 - damping) * (resetVec.get(id) ?? 0));
+    }
+    let danglingMass = 0;
+    for (const d of cache2.dangling) danglingMass += rank.get(d) ?? 0;
+    if (danglingMass > 0) {
+      const distributed = damping * danglingMass;
+      for (const [id, w] of resetVec) {
+        next.set(id, (next.get(id) ?? 0) + distributed * w);
+      }
+    }
+    for (const [id, edges] of graph.out) {
+      const s = cache2.outSum.get(id) ?? 0;
+      if (s === 0) continue;
+      const share = damping * (rank.get(id) ?? 0) / s;
+      if (share === 0) continue;
+      for (const e of edges) {
+        next.set(e.target, (next.get(e.target) ?? 0) + share * e.weight);
+      }
+    }
+    let delta = 0;
+    for (const id of graph.nodes.keys()) {
+      delta += Math.abs((next.get(id) ?? 0) - (rank.get(id) ?? 0));
+    }
+    rank = next;
+    if (delta < tol) break;
+  }
+  return rank;
+}
+function normaliseResetVec(graph, seeds) {
+  const out = /* @__PURE__ */ new Map();
+  if (!seeds || seeds.size === 0) {
+    const w = 1 / Math.max(1, graph.nodes.size);
+    for (const id of graph.nodes.keys()) out.set(id, w);
+    return out;
+  }
+  let sum = 0;
+  for (const [id, w] of seeds) {
+    if (graph.nodes.has(id) && w > 0) {
+      out.set(id, w);
+      sum += w;
+    }
+  }
+  if (sum === 0) {
+    const w = 1 / Math.max(1, graph.nodes.size);
+    for (const id of graph.nodes.keys()) out.set(id, w);
+    return out;
+  }
+  for (const [id, w] of out) out.set(id, w / sum);
+  return out;
+}
+function pagerank(graph, opts = {}) {
+  const damping = opts.damping ?? 0.85;
+  const maxIter = opts.maxIter ?? 50;
+  const tol = opts.tol ?? 1e-6;
+  const cache2 = buildOutSumCache(graph);
+  return iterate(graph, normaliseResetVec(graph), damping, maxIter, tol, cache2);
+}
+function personalizedPageRank(graph, seeds, opts = {}) {
+  const damping = opts.damping ?? 0.85;
+  const maxIter = opts.maxIter ?? 30;
+  const tol = opts.tol ?? 1e-6;
+  const topK = opts.topK ?? 0;
+  const seedMap = Array.isArray(seeds) ? new Map(seeds.map((id) => [id, 1])) : new Map(seeds);
+  const resetVec = normaliseResetVec(graph, seedMap);
+  const cache2 = buildOutSumCache(graph);
+  const ranks = iterate(graph, resetVec, damping, maxIter, tol, cache2);
+  const seedSet = new Set(seedMap.keys());
+  const results = [];
+  for (const [node, score] of ranks) {
+    if (seedSet.has(node)) continue;
+    if (score <= 0) continue;
+    results.push({ node, score });
+  }
+  results.sort((a, b) => b.score - a.score);
+  return topK > 0 ? results.slice(0, topK) : results;
+}
+
+// packages/feature/explorer/src/server/codeMap/analytics/tfidf.ts
+var TOKEN_SPLIT = /[\s_./>:\\-]+|(?<=[a-z0-9])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])/g;
+var MIN_TOKEN_LEN = 2;
+var NGRAM_SIZES = [3, 4];
+var NGRAM_WEIGHT = 0.5;
+var MIN_LEN_FOR_NGRAM = 4;
+function tokenize(text) {
+  if (!text) return [];
+  const raw = text.split(TOKEN_SPLIT);
+  const out = [];
+  for (const t of raw) {
+    if (!t) continue;
+    const low = t.toLowerCase();
+    if (low.length < MIN_TOKEN_LEN) continue;
+    out.push(low);
+  }
+  return out;
+}
+function* ngrams(s, n) {
+  if (s.length < n) return;
+  for (let i = 0; i <= s.length - n; i++) yield s.slice(i, i + n);
+}
+function weightedTokens(text) {
+  const out = [];
+  for (const word of tokenize(text)) {
+    out.push({ term: word, weight: 1 });
+    if (word.length >= MIN_LEN_FOR_NGRAM) {
+      for (const n of NGRAM_SIZES) {
+        for (const ng of ngrams(word, n)) {
+          out.push({ term: ng, weight: NGRAM_WEIGHT });
+        }
+      }
+    }
+  }
+  return out;
+}
+function nodeTokensWeighted(meta) {
+  if (!meta.tokens) {
+    meta.tokens = [
+      ...tokenize(meta.name),
+      ...tokenize(meta.qualifiedName),
+      ...tokenize(meta.filePath.replace(/\.[^./]+$/, ""))
+    ];
+  }
+  const out = [];
+  for (const word of meta.tokens) {
+    out.push({ term: word, weight: 1 });
+    if (word.length >= MIN_LEN_FOR_NGRAM) {
+      for (const n of NGRAM_SIZES) {
+        for (const ng of ngrams(word, n)) {
+          out.push({ term: ng, weight: NGRAM_WEIGHT });
+        }
+      }
+    }
+  }
+  return out;
+}
+var TfidfIndex = class {
+  constructor(graph) {
+    this.df = /* @__PURE__ */ new Map();
+    // term → doc-frequency
+    /** node → term → accumulated weight (multiple occurrences sum up). */
+    this.tfByNode = /* @__PURE__ */ new Map();
+    /** L2 norm of each doc's tfidf vector (pre-computed for cosine sim). */
+    this.normByNode = /* @__PURE__ */ new Map();
+    this.nDocs = graph.nodes.size;
+    for (const [id, meta] of graph.nodes) {
+      const weighted = nodeTokensWeighted(meta);
+      const tf = /* @__PURE__ */ new Map();
+      for (const { term, weight } of weighted) {
+        tf.set(term, (tf.get(term) ?? 0) + weight);
+      }
+      this.tfByNode.set(id, tf);
+      for (const term of tf.keys()) {
+        this.df.set(term, (this.df.get(term) ?? 0) + 1);
+      }
+    }
+    for (const [id, tf] of this.tfByNode) {
+      let s = 0;
+      for (const [term, c] of tf) {
+        const w = c * this.idf(term);
+        s += w * w;
+      }
+      this.normByNode.set(id, Math.sqrt(s) || 1);
+    }
+  }
+  idf(term) {
+    const df = this.df.get(term) ?? 0;
+    if (df === 0) return 0;
+    return Math.log((this.nDocs + 1) / (df + 1)) + 1;
+  }
+  /** Search by free-text query — cosine similarity against per-doc
+   *  tfidf vectors. Returns top-K hits by score. */
+  search(query, topK = 10) {
+    const qWeighted = weightedTokens(query);
+    if (qWeighted.length === 0) return [];
+    const qtf = /* @__PURE__ */ new Map();
+    for (const { term, weight } of qWeighted) {
+      qtf.set(term, (qtf.get(term) ?? 0) + weight);
+    }
+    const qVec = /* @__PURE__ */ new Map();
+    let qNormSq = 0;
+    for (const [term, c] of qtf) {
+      const w = c * this.idf(term);
+      if (w === 0) continue;
+      qVec.set(term, w);
+      qNormSq += w * w;
+    }
+    const qNorm = Math.sqrt(qNormSq);
+    if (qNorm === 0) return [];
+    const scores = /* @__PURE__ */ new Map();
+    for (const [node, tf] of this.tfByNode) {
+      let dot = 0;
+      for (const [term, qw] of qVec) {
+        const c = tf.get(term);
+        if (!c) continue;
+        dot += qw * (c * this.idf(term));
+      }
+      if (dot > 0) {
+        scores.set(node, dot / (qNorm * (this.normByNode.get(node) ?? 1)));
+      }
+    }
+    const out = [];
+    for (const [node, score] of scores) out.push({ node, score });
+    out.sort((a, b) => b.score - a.score);
+    return topK > 0 ? out.slice(0, topK) : out;
+  }
+};
+
+// packages/feature/explorer/src/server/codeMap/analytics/louvain.ts
+import GraphImport from "graphology";
+import louvainImport from "graphology-communities-louvain";
+var Graph = GraphImport.default ?? GraphImport;
+var louvain = louvainImport.default ?? louvainImport;
+var KEY_SEP = "\0|\0";
+function detectCommunities(graph) {
+  if (graph.nodes.size === 0) return /* @__PURE__ */ new Map();
+  const g = new Graph({ type: "undirected", multi: false });
+  for (const id of graph.nodes.keys()) g.addNode(id);
+  const seen = /* @__PURE__ */ new Map();
+  for (const [from, edges] of graph.out) {
+    for (const e of edges) {
+      if (from === e.target) continue;
+      const [u, v] = from < e.target ? [from, e.target] : [e.target, from];
+      const key = u + KEY_SEP + v;
+      seen.set(key, (seen.get(key) ?? 0) + e.weight);
+    }
+  }
+  for (const [key, weight] of seen) {
+    const sepIdx = key.indexOf(KEY_SEP);
+    if (sepIdx < 0) continue;
+    const u = key.slice(0, sepIdx);
+    const v = key.slice(sepIdx + KEY_SEP.length);
+    g.addEdgeWithKey(key, u, v, { weight });
+  }
+  const partition = louvain(g);
+  const out = /* @__PURE__ */ new Map();
+  for (const [id, c] of Object.entries(partition)) out.set(id, c);
+  return out;
+}
+
+// packages/feature/explorer/src/server/codeMap/analytics/cache.ts
+var PPRLruCache = class {
+  constructor(cap) {
+    this.map = /* @__PURE__ */ new Map();
+    this.cap = cap;
+  }
+  get(key) {
+    const v = this.map.get(key);
+    if (!v) return void 0;
+    this.map.delete(key);
+    this.map.set(key, v);
+    return v;
+  }
+  set(key, value) {
+    if (this.map.has(key)) this.map.delete(key);
+    this.map.set(key, value);
+    if (this.map.size > this.cap) {
+      const oldest = this.map.keys().next().value;
+      if (oldest !== void 0) this.map.delete(oldest);
+    }
+  }
+  clear() {
+    this.map.clear();
+  }
+  get size() {
+    return this.map.size;
+  }
+};
+var PPR_CACHE_CAP = 200;
+function pprCacheKey(seeds, opts = {}) {
+  const entries = Array.isArray(seeds) ? seeds.map((id) => [id, 1]) : [...seeds.entries()];
+  entries.sort((a, b) => a[0].localeCompare(b[0]));
+  const damping = opts.damping ?? 0.85;
+  const topK = opts.topK ?? 0;
+  return `d${damping}|k${topK}|` + entries.map((e) => `${e[0]}=${e[1]}`).join(",");
+}
+function cachedPPR(entry, seeds, opts = {}) {
+  const key = pprCacheKey(seeds, opts);
+  const hit = entry.pprCache.get(key);
+  if (hit) return hit;
+  const result = personalizedPageRank(entry.graph, seeds, opts);
+  entry.pprCache.set(key, result);
+  return result;
+}
+var cache = /* @__PURE__ */ new Map();
+var inflight = /* @__PURE__ */ new Map();
+var versionCounter = 0;
+function getAnalytics(cwd) {
+  return cache.get(cwd) ?? null;
+}
+function invalidateAnalytics(cwd) {
+  if (!cwd) {
+    cache.clear();
+    inflight.clear();
+    return;
+  }
+  cache.delete(cwd);
+  inflight.delete(cwd);
+}
+function precomputeAnalytics(cwd, index) {
+  const pending = inflight.get(cwd);
+  if (pending) return pending;
+  const p = (async () => {
+    const t0 = Date.now();
+    versionCounter += 1;
+    const version = versionCounter;
+    const graph = buildAnalyticsGraph(index, version);
+    const pr = pagerank(graph);
+    const tf = new TfidfIndex(graph);
+    const communities = detectCommunities(graph);
+    const entry = {
+      cwd,
+      version,
+      graph,
+      pagerank: pr,
+      tfidf: tf,
+      communities,
+      pprCache: new PPRLruCache(PPR_CACHE_CAP),
+      builtAt: Date.now(),
+      buildMs: Date.now() - t0
+    };
+    cache.set(cwd, entry);
+    inflight.delete(cwd);
+    return entry;
+  })();
+  inflight.set(cwd, p);
+  return p;
+}
+function getOrTriggerAnalytics(cwd, index) {
+  const hit = cache.get(cwd);
+  if (hit) return hit;
+  precomputeAnalytics(cwd, index).catch((err) => {
+    console.error("[analytics] precompute failed:", err);
+  });
+  return null;
+}
+export {
+  cachedPPR,
+  getAnalytics,
+  getOrTriggerAnalytics,
+  invalidateAnalytics,
+  precomputeAnalytics
+};

package/dist/chunk-7P6ASYW6.mjs

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/{chunk-OWUW2O3D.mjs → chunk-CZWJPTRO.mjs}

@@ -1,6 +1,5 @@
 import {
   GLOBAL_STATE_FILE,
-  __export,
   findCodexSessionPath,
   findKimiSessionPath,
   getClaude2SessionPath,
@@ -9,7 +8,10 @@ import {
   readJsonFile,
   withFileLock,
   writeJsonFile
-} from "./chunk-TXBVUZVH.mjs";
+} from "./chunk-ZJ6CC3MH.mjs";
+import {
+  __export
+} from "./chunk-7P6ASYW6.mjs";
 
 // node_modules/effect/dist/esm/Effect.js
 var Effect_exports = {};