gong-code 0.1.0

package/dist/chunk-fzkj59sg.js

@@ -0,0 +1,174 @@
+// @bun
+import {
+  __esm
+} from "./chunk-eta5aekm.js";
+import {
+  getCurrentProviderName,
+  init_config,
+  initializeProviderFromEnv
+} from "./chunk-j7qv3hvm.js";
+import {
+  getActiveProvider
+} from "./chunk-d3hb1qdr.js";
+
+// src/services/api/providers/integration.ts
+async function initializeMultiModelSupport() {
+  if (isInitialized) {
+    return;
+  }
+  await initializeProviderFromEnv();
+  isInitialized = true;
+  const providerName = getCurrentProviderName();
+  if (providerName !== "anthropic") {
+    console.log(`[Provider] Using ${providerName} instead of Anthropic`);
+  }
+}
+function shouldUseMultiModelProvider() {
+  const modelProvider = (process.env.MODEL_PROVIDER || "minimax").toLowerCase();
+  return modelProvider !== "anthropic";
+}
+function convertToUnifiedMessages(messages) {
+  return messages.map((msg) => {
+    const role = msg.type === "user" ? "user" : "assistant";
+    const content = msg.message?.content;
+    if (typeof content === "string") {
+      return { role, content };
+    }
+    if (Array.isArray(content)) {
+      const unifiedContent = content.map((c) => {
+        if (typeof c === "string") {
+          return { type: "text", text: c };
+        }
+        const block = c;
+        switch (block.type) {
+          case "text":
+            return { type: "text", text: block.text || "" };
+          case "tool_use":
+            return {
+              type: "tool_use",
+              id: block.id || "",
+              name: block.name || "",
+              input: block.input || {}
+            };
+          case "tool_result":
+            return {
+              type: "tool_result",
+              toolUseId: block.tool_use_id || "",
+              content: typeof block.content === "string" ? block.content : ""
+            };
+          default:
+            return { type: "text", text: "" };
+        }
+      });
+      return { role, content: unifiedContent };
+    }
+    return { role, content: "" };
+  });
+}
+function convertToUnifiedTools(tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description || "",
+    inputSchema: {
+      type: "object",
+      properties: tool.inputJSONSchema?.properties || {},
+      required: tool.inputJSONSchema?.required || []
+    }
+  }));
+}
+function convertFromUnifiedResponse(response) {
+  const content = response.content.map((c) => {
+    switch (c.type) {
+      case "text":
+        return { type: "text", text: c.text };
+      case "tool_use":
+        return {
+          type: "tool_use",
+          id: c.id,
+          name: c.name,
+          input: c.input
+        };
+      case "thinking":
+        return { type: "thinking", thinking: c.thinking };
+      default:
+        return { type: "text", text: "" };
+    }
+  });
+  return {
+    type: "assistant",
+    message: {
+      id: response.id,
+      role: "assistant",
+      content,
+      usage: {
+        input_tokens: response.usage.inputTokens,
+        output_tokens: response.usage.outputTokens
+      }
+    }
+  };
+}
+async function queryWithProvider({
+  messages,
+  systemPrompt,
+  tools,
+  model,
+  maxTokens,
+  signal
+}) {
+  await initializeMultiModelSupport();
+  const provider = getActiveProvider();
+  const params = {
+    messages: convertToUnifiedMessages(messages),
+    systemPrompt,
+    tools: tools ? convertToUnifiedTools(tools) : undefined,
+    model,
+    maxTokens,
+    signal
+  };
+  const response = await provider.chatSync(params);
+  return convertFromUnifiedResponse(response);
+}
+async function* queryWithProviderStreaming({
+  messages,
+  systemPrompt,
+  tools,
+  model,
+  maxTokens,
+  signal
+}) {
+  await initializeMultiModelSupport();
+  const provider = getActiveProvider();
+  const params = {
+    messages: convertToUnifiedMessages(messages),
+    systemPrompt,
+    tools: tools ? convertToUnifiedTools(tools) : undefined,
+    model,
+    maxTokens,
+    signal
+  };
+  yield* provider.chat(params);
+}
+function getProviderCapabilities() {
+  const provider = getActiveProvider();
+  return {
+    name: provider.name,
+    displayName: provider.displayName,
+    capabilities: provider.capabilities
+  };
+}
+var isInitialized = false;
+var init_integration = __esm(() => {
+  init_config();
+});
+init_integration();
+
+export {
+  shouldUseMultiModelProvider,
+  queryWithProviderStreaming,
+  queryWithProvider,
+  initializeMultiModelSupport,
+  getProviderCapabilities,
+  convertToUnifiedTools,
+  convertToUnifiedMessages,
+  convertFromUnifiedResponse
+};

package/dist/chunk-fzpzbpbw.js

@@ -0,0 +1,248 @@
+// @bun
+import"./chunk-78n9kfp8.js";
+import"./chunk-j8mxc6k6.js";
+import"./chunk-z0exw850.js";
+import"./chunk-3jf3k40v.js";
+import"./chunk-yvmhx96e.js";
+import"./chunk-qezv7msv.js";
+import"./chunk-sscms68s.js";
+import"./chunk-7e1qjk3s.js";
+import"./chunk-1gjysfnf.js";
+import"./chunk-vxgdzx6p.js";
+import"./chunk-kv147680.js";
+import"./chunk-2p0hvt8k.js";
+import"./chunk-ycr0hp6v.js";
+import"./chunk-9029sbq1.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-ezpa510h.js";
+import"./chunk-kp6nepx4.js";
+import"./chunk-1jjzp2pa.js";
+import"./chunk-w1jew5sn.js";
+import"./chunk-g98m2qe6.js";
+import"./chunk-sez03qd9.js";
+import {
+  init_log,
+  logError
+} from "./chunk-vsfj449x.js";
+import"./chunk-r4cxb6t7.js";
+import"./chunk-bp0ynk17.js";
+import"./chunk-7yexhdjs.js";
+import {
+  getFsImplementation,
+  init_debug,
+  init_errors,
+  init_fsOperations,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging,
+  toError
+} from "./chunk-rex82hys.js";
+import"./chunk-4s93jyky.js";
+import"./chunk-318g78ty.js";
+import"./chunk-c0bdmy7w.js";
+import"./chunk-syxy4pf2.js";
+import {
+  __esm
+} from "./chunk-eta5aekm.js";
+import {
+  getDesktopPath,
+  init_file
+} from "./chunk-y66bqywr.js";
+import"./chunk-nwk16bbd.js";
+import"./chunk-rx6z23h0.js";
+import"./chunk-df5c1x8m.js";
+import"./chunk-65z8hg8j.js";
+import"./chunk-5cp2q9sh.js";
+import {
+  getSessionId,
+  init_state
+} from "./chunk-rjjakkw2.js";
+import"./chunk-0sbddf6m.js";
+import"./chunk-q5b0kpr3.js";
+
+// src/utils/heapDumpService.ts
+import { createWriteStream, writeFileSync } from "fs";
+import { readdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { pipeline } from "stream/promises";
+import {
+  getHeapSnapshot,
+  getHeapSpaceStatistics,
+  getHeapStatistics
+} from "v8";
+async function captureMemoryDiagnostics(trigger, dumpNumber = 0) {
+  const usage = process.memoryUsage();
+  const heapStats = getHeapStatistics();
+  const resourceUsage = process.resourceUsage();
+  const uptimeSeconds = process.uptime();
+  let heapSpaceStats;
+  try {
+    heapSpaceStats = getHeapSpaceStatistics();
+  } catch {}
+  const activeHandles = process._getActiveHandles().length;
+  const activeRequests = process._getActiveRequests().length;
+  let openFileDescriptors;
+  try {
+    openFileDescriptors = (await readdir("/proc/self/fd")).length;
+  } catch {}
+  let smapsRollup;
+  try {
+    smapsRollup = await readFile("/proc/self/smaps_rollup", "utf8");
+  } catch {}
+  const nativeMemory = usage.rss - usage.heapUsed;
+  const bytesPerSecond = uptimeSeconds > 0 ? usage.rss / uptimeSeconds : 0;
+  const mbPerHour = bytesPerSecond * 3600 / (1024 * 1024);
+  const potentialLeaks = [];
+  if (heapStats.number_of_detached_contexts > 0) {
+    potentialLeaks.push(`${heapStats.number_of_detached_contexts} detached context(s) - possible iframe/context leak`);
+  }
+  if (activeHandles > 100) {
+    potentialLeaks.push(`${activeHandles} active handles - possible timer/socket leak`);
+  }
+  if (nativeMemory > usage.heapUsed) {
+    potentialLeaks.push("Native memory > heap - leak may be in native addons (node-pty, sharp, etc.)");
+  }
+  if (mbPerHour > 100) {
+    potentialLeaks.push(`High memory growth rate: ${mbPerHour.toFixed(1)} MB/hour`);
+  }
+  if (openFileDescriptors && openFileDescriptors > 500) {
+    potentialLeaks.push(`${openFileDescriptors} open file descriptors - possible file/socket leak`);
+  }
+  return {
+    timestamp: new Date().toISOString(),
+    sessionId: getSessionId(),
+    trigger,
+    dumpNumber,
+    uptimeSeconds,
+    memoryUsage: {
+      heapUsed: usage.heapUsed,
+      heapTotal: usage.heapTotal,
+      external: usage.external,
+      arrayBuffers: usage.arrayBuffers,
+      rss: usage.rss
+    },
+    memoryGrowthRate: {
+      bytesPerSecond,
+      mbPerHour
+    },
+    v8HeapStats: {
+      heapSizeLimit: heapStats.heap_size_limit,
+      mallocedMemory: heapStats.malloced_memory,
+      peakMallocedMemory: heapStats.peak_malloced_memory,
+      detachedContexts: heapStats.number_of_detached_contexts,
+      nativeContexts: heapStats.number_of_native_contexts
+    },
+    v8HeapSpaces: heapSpaceStats?.map((space) => ({
+      name: space.space_name,
+      size: space.space_size,
+      used: space.space_used_size,
+      available: space.space_available_size
+    })),
+    resourceUsage: {
+      maxRSS: resourceUsage.maxRSS * 1024,
+      userCPUTime: resourceUsage.userCPUTime,
+      systemCPUTime: resourceUsage.systemCPUTime
+    },
+    activeHandles,
+    activeRequests,
+    openFileDescriptors,
+    analysis: {
+      potentialLeaks,
+      recommendation: potentialLeaks.length > 0 ? `WARNING: ${potentialLeaks.length} potential leak indicator(s) found. See potentialLeaks array.` : "No obvious leak indicators. Check heap snapshot for retained objects."
+    },
+    smapsRollup,
+    platform: process.platform,
+    nodeVersion: process.version,
+    ccVersion: MACRO.VERSION
+  };
+}
+async function performHeapDump(trigger = "manual", dumpNumber = 0) {
+  try {
+    const sessionId = getSessionId();
+    const diagnostics = await captureMemoryDiagnostics(trigger, dumpNumber);
+    const toGB = (bytes) => (bytes / 1024 / 1024 / 1024).toFixed(3);
+    logForDebugging(`[HeapDump] Memory state:
+  heapUsed: ${toGB(diagnostics.memoryUsage.heapUsed)} GB (in snapshot)
+  external: ${toGB(diagnostics.memoryUsage.external)} GB (NOT in snapshot)
+  rss: ${toGB(diagnostics.memoryUsage.rss)} GB (total process)
+  ${diagnostics.analysis.recommendation}`);
+    const dumpDir = getDesktopPath();
+    await getFsImplementation().mkdir(dumpDir);
+    const suffix = dumpNumber > 0 ? `-dump${dumpNumber}` : "";
+    const heapFilename = `${sessionId}${suffix}.heapsnapshot`;
+    const diagFilename = `${sessionId}${suffix}-diagnostics.json`;
+    const heapPath = join(dumpDir, heapFilename);
+    const diagPath = join(dumpDir, diagFilename);
+    await writeFile(diagPath, jsonStringify(diagnostics, null, 2), {
+      mode: 384
+    });
+    logForDebugging(`[HeapDump] Diagnostics written to ${diagPath}`);
+    await writeHeapSnapshot(heapPath);
+    logForDebugging(`[HeapDump] Heap dump written to ${heapPath}`);
+    logEvent("tengu_heap_dump", {
+      triggerManual: trigger === "manual",
+      triggerAuto15GB: trigger === "auto-1.5GB",
+      dumpNumber,
+      success: true
+    });
+    return { success: true, heapPath, diagPath };
+  } catch (err) {
+    const error = toError(err);
+    logError(error);
+    logEvent("tengu_heap_dump", {
+      triggerManual: trigger === "manual",
+      triggerAuto15GB: trigger === "auto-1.5GB",
+      dumpNumber,
+      success: false
+    });
+    return { success: false, error: error.message };
+  }
+}
+async function writeHeapSnapshot(filepath) {
+  if (typeof Bun !== "undefined") {
+    writeFileSync(filepath, Bun.generateHeapSnapshot("v8", "arraybuffer"), {
+      mode: 384
+    });
+    Bun.gc(true);
+    return;
+  }
+  const writeStream = createWriteStream(filepath, { mode: 384 });
+  const heapSnapshotStream = getHeapSnapshot();
+  await pipeline(heapSnapshotStream, writeStream);
+}
+var init_heapDumpService = __esm(() => {
+  init_state();
+  init_analytics();
+  init_debug();
+  init_errors();
+  init_file();
+  init_fsOperations();
+  init_log();
+  init_slowOperations();
+});
+
+// src/commands/heapdump/heapdump.ts
+async function call() {
+  const result = await performHeapDump();
+  if (!result.success) {
+    return {
+      type: "text",
+      value: `Failed to create heap dump: ${result.error}`
+    };
+  }
+  return {
+    type: "text",
+    value: `${result.heapPath}
+${result.diagPath}`
+  };
+}
+var init_heapdump = __esm(() => {
+  init_heapDumpService();
+});
+init_heapdump();
+
+export {
+  call
+};