@costrict/csc 4.0.1

package/dist/chunk-yja33bsx.js

@@ -0,0 +1,300 @@
+// @bun
+import {
+  checkAndRefreshOAuthTokenIfNeeded,
+  getClaudeAIOAuthTokens,
+  getFeatureValue_CACHED_MAY_BE_STALE,
+  getUserAgent,
+  init_auth,
+  init_growthbook,
+  init_http,
+  isAnthropicAuthEnabled
+} from "./chunk-qp1047f9.js";
+import {
+  getWebSocketProxyAgent,
+  getWebSocketProxyUrl,
+  getWebSocketTLSOptions,
+  init_mtls,
+  init_proxy
+} from "./chunk-1dz5e26z.js";
+import {
+  getOauthConfig,
+  init_oauth
+} from "./chunk-q82r31er.js";
+import {
+  init_log,
+  logError
+} from "./chunk-ce2v5y9y.js";
+import {
+  init_debug,
+  init_slowOperations,
+  jsonParse,
+  jsonStringify,
+  logForDebugging
+} from "./chunk-ctya0ggm.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/voiceStreamSTT.ts
+import WebSocket from "ws";
+function isVoiceStreamAvailable() {
+  if (!isAnthropicAuthEnabled()) {
+    return false;
+  }
+  const tokens = getClaudeAIOAuthTokens();
+  return tokens !== null && tokens.accessToken !== null;
+}
+async function connectVoiceStream(callbacks, options) {
+  await checkAndRefreshOAuthTokenIfNeeded();
+  const tokens = getClaudeAIOAuthTokens();
+  if (!tokens?.accessToken) {
+    logForDebugging("[voice_stream] No OAuth token available");
+    return null;
+  }
+  const wsBaseUrl = process.env.VOICE_STREAM_BASE_URL || getOauthConfig().BASE_API_URL.replace("https://", "wss://").replace("http://", "ws://");
+  if (process.env.VOICE_STREAM_BASE_URL) {
+    logForDebugging(`[voice_stream] Using VOICE_STREAM_BASE_URL override: ${process.env.VOICE_STREAM_BASE_URL}`);
+  }
+  const params = new URLSearchParams({
+    encoding: "linear16",
+    sample_rate: "16000",
+    channels: "1",
+    endpointing_ms: "300",
+    utterance_end_ms: "1000",
+    language: options?.language ?? "en"
+  });
+  const isNova3 = getFeatureValue_CACHED_MAY_BE_STALE("tengu_cobalt_frost", false);
+  if (isNova3) {
+    params.set("use_conversation_engine", "true");
+    params.set("stt_provider", "deepgram-nova3");
+    logForDebugging("[voice_stream] Nova 3 gate enabled (tengu_cobalt_frost)");
+  }
+  if (options?.keyterms?.length) {
+    for (const term of options.keyterms) {
+      params.append("keyterms", term);
+    }
+  }
+  const url = `${wsBaseUrl}${VOICE_STREAM_PATH}?${params.toString()}`;
+  logForDebugging(`[voice_stream] Connecting to ${url}`);
+  const headers = {
+    Authorization: `Bearer ${tokens.accessToken}`,
+    "User-Agent": getUserAgent(),
+    "x-app": "cli"
+  };
+  const tlsOptions = getWebSocketTLSOptions();
+  const wsOptions = typeof Bun !== "undefined" ? {
+    headers,
+    proxy: getWebSocketProxyUrl(url),
+    tls: tlsOptions || undefined
+  } : { headers, agent: getWebSocketProxyAgent(url), ...tlsOptions };
+  const ws = new WebSocket(url, wsOptions);
+  let keepaliveTimer = null;
+  let connected = false;
+  let finalized = false;
+  let finalizing = false;
+  let upgradeRejected = false;
+  let resolveFinalize = null;
+  let cancelNoDataTimer = null;
+  const connection = {
+    send(audioChunk) {
+      if (ws.readyState !== WebSocket.OPEN) {
+        return;
+      }
+      if (finalized) {
+        logForDebugging(`[voice_stream] Dropping audio chunk after CloseStream: ${String(audioChunk.length)} bytes`);
+        return;
+      }
+      logForDebugging(`[voice_stream] Sending audio chunk: ${String(audioChunk.length)} bytes`);
+      ws.send(Buffer.from(audioChunk));
+    },
+    finalize() {
+      if (finalizing || finalized) {
+        return Promise.resolve("ws_already_closed");
+      }
+      finalizing = true;
+      return new Promise((resolve) => {
+        const safetyTimer = setTimeout(() => resolveFinalize?.("safety_timeout"), FINALIZE_TIMEOUTS_MS.safety);
+        const noDataTimer = setTimeout(() => resolveFinalize?.("no_data_timeout"), FINALIZE_TIMEOUTS_MS.noData);
+        cancelNoDataTimer = () => {
+          clearTimeout(noDataTimer);
+          cancelNoDataTimer = null;
+        };
+        resolveFinalize = (source) => {
+          clearTimeout(safetyTimer);
+          clearTimeout(noDataTimer);
+          resolveFinalize = null;
+          cancelNoDataTimer = null;
+          if (lastTranscriptText) {
+            logForDebugging(`[voice_stream] Promoting unreported interim before ${source} resolve`);
+            const t = lastTranscriptText;
+            lastTranscriptText = "";
+            callbacks.onTranscript(t, true);
+          }
+          logForDebugging(`[voice_stream] Finalize resolved via ${source}`);
+          resolve(source);
+        };
+        if (ws.readyState === WebSocket.CLOSED || ws.readyState === WebSocket.CLOSING) {
+          resolveFinalize("ws_already_closed");
+          return;
+        }
+        setTimeout(() => {
+          finalized = true;
+          if (ws.readyState === WebSocket.OPEN) {
+            logForDebugging("[voice_stream] Sending CloseStream (finalize)");
+            ws.send(CLOSE_STREAM_MSG);
+          }
+        }, 0);
+      });
+    },
+    close() {
+      finalized = true;
+      if (keepaliveTimer) {
+        clearInterval(keepaliveTimer);
+        keepaliveTimer = null;
+      }
+      connected = false;
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.close();
+      }
+    },
+    isConnected() {
+      return connected && ws.readyState === WebSocket.OPEN;
+    }
+  };
+  ws.on("open", () => {
+    logForDebugging("[voice_stream] WebSocket connected");
+    connected = true;
+    logForDebugging("[voice_stream] Sending initial KeepAlive");
+    ws.send(KEEPALIVE_MSG);
+    keepaliveTimer = setInterval((ws2) => {
+      if (ws2.readyState === WebSocket.OPEN) {
+        logForDebugging("[voice_stream] Sending periodic KeepAlive");
+        ws2.send(KEEPALIVE_MSG);
+      }
+    }, KEEPALIVE_INTERVAL_MS, ws);
+    callbacks.onReady(connection);
+  });
+  let lastTranscriptText = "";
+  ws.on("message", (raw) => {
+    const text = raw.toString();
+    logForDebugging(`[voice_stream] Message received (${String(text.length)} chars): ${text.slice(0, 200)}`);
+    let msg;
+    try {
+      msg = jsonParse(text);
+    } catch {
+      return;
+    }
+    switch (msg.type) {
+      case "TranscriptText": {
+        const transcript = msg.data;
+        logForDebugging(`[voice_stream] TranscriptText: "${transcript ?? ""}"`);
+        if (finalized) {
+          cancelNoDataTimer?.();
+        }
+        if (transcript) {
+          if (!isNova3 && lastTranscriptText) {
+            const prev = lastTranscriptText.trimStart();
+            const next = transcript.trimStart();
+            if (prev && next && !next.startsWith(prev) && !prev.startsWith(next)) {
+              logForDebugging(`[voice_stream] Auto-finalizing previous segment (new segment detected): "${lastTranscriptText}"`);
+              callbacks.onTranscript(lastTranscriptText, true);
+            }
+          }
+          lastTranscriptText = transcript;
+          callbacks.onTranscript(transcript, false);
+        }
+        break;
+      }
+      case "TranscriptEndpoint": {
+        logForDebugging(`[voice_stream] TranscriptEndpoint received, lastTranscriptText="${lastTranscriptText}"`);
+        const finalText = lastTranscriptText;
+        lastTranscriptText = "";
+        if (finalText) {
+          callbacks.onTranscript(finalText, true);
+        }
+        if (finalized) {
+          resolveFinalize?.("post_closestream_endpoint");
+        }
+        break;
+      }
+      case "TranscriptError": {
+        const desc = msg.description ?? msg.error_code ?? "unknown transcription error";
+        logForDebugging(`[voice_stream] TranscriptError: ${desc}`);
+        if (!finalizing) {
+          callbacks.onError(desc);
+        }
+        break;
+      }
+      case "error": {
+        const errorDetail = msg.message ?? jsonStringify(msg);
+        logForDebugging(`[voice_stream] Server error: ${errorDetail}`);
+        if (!finalizing) {
+          callbacks.onError(errorDetail);
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  });
+  ws.on("close", (code, reason) => {
+    const reasonStr = reason?.toString() ?? "";
+    logForDebugging(`[voice_stream] WebSocket closed: code=${String(code)} reason="${reasonStr}"`);
+    connected = false;
+    if (keepaliveTimer) {
+      clearInterval(keepaliveTimer);
+      keepaliveTimer = null;
+    }
+    if (lastTranscriptText) {
+      logForDebugging("[voice_stream] Promoting unreported interim transcript to final on close");
+      const finalText = lastTranscriptText;
+      lastTranscriptText = "";
+      callbacks.onTranscript(finalText, true);
+    }
+    resolveFinalize?.("ws_close");
+    if (!finalizing && !upgradeRejected && code !== 1000 && code !== 1005) {
+      callbacks.onError(`Connection closed: code ${String(code)}${reasonStr ? ` \u2014 ${reasonStr}` : ""}`);
+    }
+    callbacks.onClose();
+  });
+  ws.on("unexpected-response", (req, res) => {
+    const status = res.statusCode ?? 0;
+    if (status === 101) {
+      logForDebugging("[voice_stream] unexpected-response fired with 101; ignoring");
+      return;
+    }
+    logForDebugging(`[voice_stream] Upgrade rejected: status=${String(status)} cf-mitigated=${String(res.headers["cf-mitigated"])} cf-ray=${String(res.headers["cf-ray"])}`);
+    upgradeRejected = true;
+    res.resume();
+    req.destroy();
+    if (finalizing)
+      return;
+    callbacks.onError(`WebSocket upgrade rejected with HTTP ${String(status)}`, { fatal: status >= 400 && status < 500 });
+  });
+  ws.on("error", (err) => {
+    logError(err);
+    logForDebugging(`[voice_stream] WebSocket error: ${err.message}`);
+    if (!finalizing) {
+      callbacks.onError(`Voice stream connection error: ${err.message}`);
+    }
+  });
+  return connection;
+}
+var KEEPALIVE_MSG = '{"type":"KeepAlive"}', CLOSE_STREAM_MSG = '{"type":"CloseStream"}', VOICE_STREAM_PATH = "/api/ws/speech_to_text/voice_stream", KEEPALIVE_INTERVAL_MS = 8000, FINALIZE_TIMEOUTS_MS;
+var init_voiceStreamSTT = __esm(() => {
+  init_oauth();
+  init_auth();
+  init_debug();
+  init_http();
+  init_log();
+  init_mtls();
+  init_proxy();
+  init_slowOperations();
+  init_growthbook();
+  FINALIZE_TIMEOUTS_MS = {
+    safety: 5000,
+    noData: 1500
+  };
+});
+
+export { FINALIZE_TIMEOUTS_MS, isVoiceStreamAvailable, connectVoiceStream, init_voiceStreamSTT };

package/dist/chunk-yjkamwzv.js

@@ -0,0 +1,121 @@
+// @bun
+import {
+  getRemoteUrl,
+  init_git
+} from "./chunk-13hhjhs8.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-b81hd3m6.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-ctya0ggm.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/detectRepository.ts
+function clearRepositoryCaches() {
+  repositoryWithHostCache.clear();
+}
+async function detectCurrentRepository() {
+  const result = await detectCurrentRepositoryWithHost();
+  if (!result)
+    return null;
+  if (result.host !== "github.com")
+    return null;
+  return `${result.owner}/${result.name}`;
+}
+async function detectCurrentRepositoryWithHost() {
+  const cwd = getCwd();
+  if (repositoryWithHostCache.has(cwd)) {
+    return repositoryWithHostCache.get(cwd) ?? null;
+  }
+  try {
+    const remoteUrl = await getRemoteUrl();
+    logForDebugging(`Git remote URL: ${remoteUrl}`);
+    if (!remoteUrl) {
+      logForDebugging("No git remote URL found");
+      repositoryWithHostCache.set(cwd, null);
+      return null;
+    }
+    const parsed = parseGitRemote(remoteUrl);
+    logForDebugging(`Parsed repository: ${parsed ? `${parsed.host}/${parsed.owner}/${parsed.name}` : null} from URL: ${remoteUrl}`);
+    repositoryWithHostCache.set(cwd, parsed);
+    return parsed;
+  } catch (error) {
+    logForDebugging(`Error detecting repository: ${error}`);
+    repositoryWithHostCache.set(cwd, null);
+    return null;
+  }
+}
+function getCachedRepository() {
+  const parsed = repositoryWithHostCache.get(getCwd());
+  if (!parsed || parsed.host !== "github.com")
+    return null;
+  return `${parsed.owner}/${parsed.name}`;
+}
+function parseGitRemote(input) {
+  const trimmed = input.trim();
+  const sshMatch = trimmed.match(/^git@([^:]+):([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (sshMatch?.[1] && sshMatch[2] && sshMatch[3]) {
+    if (!looksLikeRealHostname(sshMatch[1]))
+      return null;
+    return {
+      host: sshMatch[1],
+      owner: sshMatch[2],
+      name: sshMatch[3]
+    };
+  }
+  const urlMatch = trimmed.match(/^(https?|ssh|git):\/\/(?:[^@]+@)?([^/:]+(?::\d+)?)\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+  if (urlMatch?.[1] && urlMatch[2] && urlMatch[3] && urlMatch[4]) {
+    const protocol = urlMatch[1];
+    const hostWithPort = urlMatch[2];
+    const hostWithoutPort = hostWithPort.split(":")[0] ?? "";
+    if (!looksLikeRealHostname(hostWithoutPort))
+      return null;
+    const host = protocol === "https" || protocol === "http" ? hostWithPort : hostWithoutPort;
+    return {
+      host,
+      owner: urlMatch[3],
+      name: urlMatch[4]
+    };
+  }
+  return null;
+}
+function parseGitHubRepository(input) {
+  const trimmed = input.trim();
+  const parsed = parseGitRemote(trimmed);
+  if (parsed) {
+    if (parsed.host !== "github.com")
+      return null;
+    return `${parsed.owner}/${parsed.name}`;
+  }
+  if (!trimmed.includes("://") && !trimmed.includes("@") && trimmed.includes("/")) {
+    const parts = trimmed.split("/");
+    if (parts.length === 2 && parts[0] && parts[1]) {
+      const repo = parts[1].replace(/\.git$/, "");
+      return `${parts[0]}/${repo}`;
+    }
+  }
+  logForDebugging(`Could not parse repository from: ${trimmed}`);
+  return null;
+}
+function looksLikeRealHostname(host) {
+  if (!host.includes("."))
+    return false;
+  const lastSegment = host.split(".").pop();
+  if (!lastSegment)
+    return false;
+  return /^[a-zA-Z]+$/.test(lastSegment);
+}
+var repositoryWithHostCache;
+var init_detectRepository = __esm(() => {
+  init_cwd();
+  init_debug();
+  init_git();
+  repositoryWithHostCache = new Map;
+});
+
+export { clearRepositoryCaches, detectCurrentRepository, detectCurrentRepositoryWithHost, getCachedRepository, parseGitRemote, parseGitHubRepository, init_detectRepository };

package/dist/chunk-ymjz2by8.js

@@ -0,0 +1,120 @@
+// @bun
+import {
+  init_config1 as init_config,
+  saveCurrentProjectConfig
+} from "./chunk-qp1047f9.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/context/stats.tsx
+init_config();
+var import_react = __toESM(require_react(), 1);
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+function percentile(sorted, p) {
+  const index = p / 100 * (sorted.length - 1);
+  const lower = Math.floor(index);
+  const upper = Math.ceil(index);
+  if (lower === upper) {
+    return sorted[lower];
+  }
+  return sorted[lower] + (sorted[upper] - sorted[lower]) * (index - lower);
+}
+var RESERVOIR_SIZE = 1024;
+function createStatsStore() {
+  const metrics = new Map;
+  const histograms = new Map;
+  const sets = new Map;
+  return {
+    increment(name, value = 1) {
+      metrics.set(name, (metrics.get(name) ?? 0) + value);
+    },
+    set(name, value) {
+      metrics.set(name, value);
+    },
+    observe(name, value) {
+      let h = histograms.get(name);
+      if (!h) {
+        h = { reservoir: [], count: 0, sum: 0, min: value, max: value };
+        histograms.set(name, h);
+      }
+      h.count++;
+      h.sum += value;
+      if (value < h.min) {
+        h.min = value;
+      }
+      if (value > h.max) {
+        h.max = value;
+      }
+      if (h.reservoir.length < RESERVOIR_SIZE) {
+        h.reservoir.push(value);
+      } else {
+        const j = Math.floor(Math.random() * h.count);
+        if (j < RESERVOIR_SIZE) {
+          h.reservoir[j] = value;
+        }
+      }
+    },
+    add(name, value) {
+      let s = sets.get(name);
+      if (!s) {
+        s = new Set;
+        sets.set(name, s);
+      }
+      s.add(value);
+    },
+    getAll() {
+      const result = Object.fromEntries(metrics);
+      for (const [name, h] of histograms) {
+        if (h.count === 0) {
+          continue;
+        }
+        result[`${name}_count`] = h.count;
+        result[`${name}_min`] = h.min;
+        result[`${name}_max`] = h.max;
+        result[`${name}_avg`] = h.sum / h.count;
+        const sorted = [...h.reservoir].sort((a, b) => a - b);
+        result[`${name}_p50`] = percentile(sorted, 50);
+        result[`${name}_p95`] = percentile(sorted, 95);
+        result[`${name}_p99`] = percentile(sorted, 99);
+      }
+      for (const [name, s] of sets) {
+        result[name] = s.size;
+      }
+      return result;
+    }
+  };
+}
+var StatsContext = import_react.createContext(null);
+function StatsProvider({
+  store: externalStore,
+  children
+}) {
+  const internalStore = import_react.useMemo(() => createStatsStore(), []);
+  const store = externalStore ?? internalStore;
+  import_react.useEffect(() => {
+    const flush = () => {
+      const metrics = store.getAll();
+      if (Object.keys(metrics).length > 0) {
+        saveCurrentProjectConfig((current) => ({
+          ...current,
+          lastSessionMetrics: metrics
+        }));
+      }
+    };
+    process.on("exit", flush);
+    return () => {
+      process.off("exit", flush);
+    };
+  }, [store]);
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(StatsContext.Provider, {
+    value: store,
+    children
+  }, undefined, false, undefined, this);
+}
+
+export { createStatsStore, StatsProvider };

package/dist/chunk-yqtda7b6.js

@@ -0,0 +1,105 @@
+// @bun
+import {
+  CHANGELOG_URL,
+  fetchAndStoreChangelog,
+  getAllReleaseNotes,
+  getStoredChangelog,
+  init_releaseNotes
+} from "./chunk-j7e5xs2n.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-qp1047f9.js";
+import"./chunk-3ns6ys7f.js";
+import"./chunk-6aspnjtj.js";
+import"./chunk-1dz5e26z.js";
+import"./chunk-1cwdhk7a.js";
+import"./chunk-j9gxwbe3.js";
+import"./chunk-64c1avct.js";
+import"./chunk-qbrsmra3.js";
+import"./chunk-8g5pe1gr.js";
+import"./chunk-5j8wked2.js";
+import"./chunk-4pbx3g7s.js";
+import"./chunk-26wtxbdc.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-rcpmj2s6.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-dkzwgrsa.js";
+import"./chunk-q82r31er.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-ztf1hdpb.js";
+import"./chunk-crmjpsqe.js";
+import"./chunk-fk80f449.js";
+import"./chunk-g338npwr.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-13hhjhs8.js";
+import"./chunk-rpmxbsc4.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-2wz9qb4j.js";
+import"./chunk-b81hd3m6.js";
+import"./chunk-ce2v5y9y.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-56r79b2b.js";
+import"./chunk-nneembm7.js";
+import"./chunk-5z28bqne.js";
+import"./chunk-qajrkk97.js";
+import"./chunk-ctya0ggm.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-z6e5jp2w.js";
+import"./chunk-h4b85amj.js";
+import"./chunk-07069jq1.js";
+import"./chunk-jaaxk89e.js";
+import"./chunk-vf612n57.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-nh3cd07f.js";
+import"./chunk-8pn8tvgg.js";
+import"./chunk-netzwgv1.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
+};