gong-code 0.1.0

package/dist/chunk-mcg5ttj4.js

@@ -0,0 +1,105 @@
+// @bun
+import {
+  __esm,
+  __require
+} from "./chunk-eta5aekm.js";
+
+// packages/image-processor-napi/src/index.ts
+import sharpModule from "sharp";
+function createDarwinNativeModule() {
+  return {
+    hasClipboardImage() {
+      try {
+        const result = Bun.spawnSync({
+          cmd: [
+            "osascript",
+            "-e",
+            `try
+the clipboard as \xABclass PNGf\xBB
+return "yes"
+on error
+return "no"
+end try`
+          ],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        const output = result.stdout.toString().trim();
+        return output === "yes";
+      } catch {
+        return false;
+      }
+    },
+    readClipboardImage(maxWidth, maxHeight) {
+      try {
+        const tmpPath = `/tmp/claude_clipboard_native_${Date.now()}.png`;
+        const script = `
+set png_data to (the clipboard as \xABclass PNGf\xBB)
+set fp to open for access POSIX file "${tmpPath}" with write permission
+write png_data to fp
+close access fp
+return "${tmpPath}"
+`;
+        const result = Bun.spawnSync({
+          cmd: ["osascript", "-e", script],
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        if (result.exitCode !== 0) {
+          return null;
+        }
+        const file = Bun.file(tmpPath);
+        const fs = __require("fs");
+        const buffer = fs.readFileSync(tmpPath);
+        try {
+          fs.unlinkSync(tmpPath);
+        } catch {}
+        if (buffer.length === 0) {
+          return null;
+        }
+        let width = 0;
+        let height = 0;
+        if (buffer.length > 24 && buffer[12] === 73 && buffer[13] === 72 && buffer[14] === 68 && buffer[15] === 82) {
+          width = buffer.readUInt32BE(16);
+          height = buffer.readUInt32BE(20);
+        }
+        const originalWidth = width;
+        const originalHeight = height;
+        if (maxWidth && maxHeight) {
+          if (width > maxWidth || height > maxHeight) {
+            const scale = Math.min(maxWidth / width, maxHeight / height);
+            width = Math.round(width * scale);
+            height = Math.round(height * scale);
+          }
+        }
+        return {
+          png: buffer,
+          width,
+          height,
+          originalWidth,
+          originalHeight
+        };
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+function getNativeModule() {
+  if (process.platform === "darwin") {
+    return createDarwinNativeModule();
+  }
+  return null;
+}
+var sharp, src_default;
+var init_src = __esm(() => {
+  sharp = sharpModule;
+  src_default = sharp;
+});
+init_src();
+
+export {
+  sharp,
+  getNativeModule,
+  src_default as default
+};

package/dist/chunk-mf4r7918.js

@@ -0,0 +1,63 @@
+// @bun
+import {
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-4s93jyky.js";
+import"./chunk-318g78ty.js";
+import {
+  __esm
+} from "./chunk-eta5aekm.js";
+
+// src/utils/subprocessEnv.ts
+function registerUpstreamProxyEnvFn(fn) {
+  _getUpstreamProxyEnv = fn;
+}
+function subprocessEnv() {
+  const proxyEnv = _getUpstreamProxyEnv?.() ?? {};
+  if (!isEnvTruthy(process.env.CLAUDE_CODE_SUBPROCESS_ENV_SCRUB)) {
+    return Object.keys(proxyEnv).length > 0 ? { ...process.env, ...proxyEnv } : process.env;
+  }
+  const env = { ...process.env, ...proxyEnv };
+  for (const k of GHA_SUBPROCESS_SCRUB) {
+    delete env[k];
+    delete env[`INPUT_${k}`];
+  }
+  return env;
+}
+var GHA_SUBPROCESS_SCRUB, _getUpstreamProxyEnv;
+var init_subprocessEnv = __esm(() => {
+  init_envUtils();
+  GHA_SUBPROCESS_SCRUB = [
+    "ANTHROPIC_API_KEY",
+    "CLAUDE_CODE_OAUTH_TOKEN",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_FOUNDRY_API_KEY",
+    "ANTHROPIC_CUSTOM_HEADERS",
+    "OTEL_EXPORTER_OTLP_HEADERS",
+    "OTEL_EXPORTER_OTLP_LOGS_HEADERS",
+    "OTEL_EXPORTER_OTLP_METRICS_HEADERS",
+    "OTEL_EXPORTER_OTLP_TRACES_HEADERS",
+    "AWS_SECRET_ACCESS_KEY",
+    "AWS_SESSION_TOKEN",
+    "AWS_BEARER_TOKEN_BEDROCK",
+    "GOOGLE_APPLICATION_CREDENTIALS",
+    "AZURE_CLIENT_SECRET",
+    "AZURE_CLIENT_CERTIFICATE_PATH",
+    "ACTIONS_ID_TOKEN_REQUEST_TOKEN",
+    "ACTIONS_ID_TOKEN_REQUEST_URL",
+    "ACTIONS_RUNTIME_TOKEN",
+    "ACTIONS_RUNTIME_URL",
+    "ALL_INPUTS",
+    "OVERRIDE_GITHUB_TOKEN",
+    "DEFAULT_WORKFLOW_TOKEN",
+    "SSH_SIGNING_KEY"
+  ];
+});
+init_subprocessEnv();
+
+export {
+  subprocessEnv,
+  registerUpstreamProxyEnvFn
+};
+
+export { subprocessEnv, init_subprocessEnv };

package/dist/chunk-mh9khrt4.js

@@ -0,0 +1,286 @@
+// @bun
+import"./chunk-jevj87jn.js";
+import"./chunk-qztvd4hd.js";
+import"./chunk-q0xkrxy8.js";
+import"./chunk-52dzw4bc.js";
+import"./chunk-n6q02ya9.js";
+import"./chunk-b4tpz2g1.js";
+import"./chunk-n3agghys.js";
+import"./chunk-f9rahzgr.js";
+import"./chunk-ex41stfq.js";
+import"./chunk-8n4n4m67.js";
+import"./chunk-xjr0n27e.js";
+import"./chunk-0yz17yjy.js";
+import"./chunk-9m5rn7hk.js";
+import"./chunk-19jvvqzp.js";
+import"./chunk-2n0s2dhc.js";
+import"./chunk-epwrzr35.js";
+import"./chunk-1ztm9yps.js";
+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-zb2xrj5t.js";
+import"./chunk-9029sbq1.js";
+import"./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 {
+  hasExactErrorMessage,
+  init_errors
+} 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 {
+  ERROR_MESSAGE_INCOMPLETE_RESPONSE,
+  ERROR_MESSAGE_NOT_ENOUGH_MESSAGES,
+  ERROR_MESSAGE_USER_ABORT,
+  buildEffectiveSystemPrompt,
+  compactConversation,
+  executePreCompactHooks,
+  getMessagesAfterCompactBoundary,
+  getShortcutDisplay,
+  getSystemContext,
+  getSystemPrompt,
+  getUpgradeMessage,
+  getUserContext,
+  init_compact,
+  init_compactWarningState,
+  init_context,
+  init_contextWindowUpgradeCheck,
+  init_hooks1 as init_hooks,
+  init_messages,
+  init_microCompact,
+  init_postCompactCleanup,
+  init_promptCacheBreakDetection,
+  init_prompts1 as init_prompts,
+  init_sessionMemoryCompact,
+  init_sessionMemoryUtils,
+  init_shortcutFormat,
+  init_systemPrompt,
+  mergeHookInstructions,
+  microcompactMessages,
+  runPostCompactCleanup,
+  setLastSummarizedMessageId,
+  suppressCompactWarning,
+  trySessionMemoryCompaction
+} from "./chunk-ccyg9ap9.js";
+import"./chunk-846rr9n1.js";
+import"./chunk-fnnpqv92.js";
+import"./chunk-2yqy25z4.js";
+import"./chunk-zygzzzvk.js";
+import"./chunk-evp72hv5.js";
+import"./chunk-jz7tbdyv.js";
+import"./chunk-vxqhjyfz.js";
+import"./chunk-mf4r7918.js";
+import"./chunk-sywdxbs6.js";
+import"./chunk-cjqxdnf9.js";
+import"./chunk-9qasfk8n.js";
+import"./chunk-fpd3zzx1.js";
+import"./chunk-bv4c48a5.js";
+import"./chunk-6jta29r1.js";
+import"./chunk-z4rzc9nd.js";
+import"./chunk-9bs8n985.js";
+import"./chunk-6xqp51qr.js";
+import"./chunk-35dw2r9g.js";
+import {
+  init_source,
+  source_default
+} from "./chunk-y66bqywr.js";
+import"./chunk-nwk16bbd.js";
+import"./chunk-rx6z23h0.js";
+import"./chunk-df5c1x8m.js";
+import"./chunk-qwrp63wh.js";
+import"./chunk-65z8hg8j.js";
+import"./chunk-5cp2q9sh.js";
+import {
+  init_state,
+  markPostCompaction
+} from "./chunk-rjjakkw2.js";
+import"./chunk-0sbddf6m.js";
+import"./chunk-q5b0kpr3.js";
+
+// src/commands/compact/compact.ts
+async function compactViaReactive(messages, context, customInstructions, reactive) {
+  context.onCompactProgress?.({
+    type: "hooks_start",
+    hookType: "pre_compact"
+  });
+  context.setSDKStatus?.("compacting");
+  try {
+    const [hookResult, cacheSafeParams] = await Promise.all([
+      executePreCompactHooks({ trigger: "manual", customInstructions: customInstructions || null }, context.abortController.signal),
+      getCacheSharingParams(context, messages)
+    ]);
+    const mergedInstructions = mergeHookInstructions(customInstructions, hookResult.newCustomInstructions);
+    context.setStreamMode?.("requesting");
+    context.setResponseLength?.(() => 0);
+    context.onCompactProgress?.({ type: "compact_start" });
+    const outcome = await reactive.reactiveCompactOnPromptTooLong(messages, cacheSafeParams, { customInstructions: mergedInstructions, trigger: "manual" });
+    if (!outcome.ok) {
+      switch (outcome.reason) {
+        case "too_few_groups":
+          throw new Error(ERROR_MESSAGE_NOT_ENOUGH_MESSAGES);
+        case "aborted":
+          throw new Error(ERROR_MESSAGE_USER_ABORT);
+        case "exhausted":
+        case "error":
+        case "media_unstrippable":
+          throw new Error(ERROR_MESSAGE_INCOMPLETE_RESPONSE);
+      }
+    }
+    setLastSummarizedMessageId(undefined);
+    runPostCompactCleanup();
+    suppressCompactWarning();
+    getUserContext.cache.clear?.();
+    const combinedMessage = [hookResult.userDisplayMessage, outcome.result.userDisplayMessage].filter(Boolean).join(`
+`) || undefined;
+    return {
+      type: "compact",
+      compactionResult: {
+        ...outcome.result,
+        userDisplayMessage: combinedMessage
+      },
+      displayText: buildDisplayText(context, combinedMessage)
+    };
+  } finally {
+    context.setStreamMode?.("requesting");
+    context.setResponseLength?.(() => 0);
+    context.onCompactProgress?.({ type: "compact_end" });
+    context.setSDKStatus?.(null);
+  }
+}
+function buildDisplayText(context, userDisplayMessage) {
+  const upgradeMessage = getUpgradeMessage("tip");
+  const expandShortcut = getShortcutDisplay("app:toggleTranscript", "Global", "ctrl+o");
+  const dimmed = [
+    ...context.options.verbose ? [] : [`(${expandShortcut} to see full summary)`],
+    ...userDisplayMessage ? [userDisplayMessage] : [],
+    ...upgradeMessage ? [upgradeMessage] : []
+  ];
+  return source_default.dim("Compacted " + dimmed.join(`
+`));
+}
+async function getCacheSharingParams(context, forkContextMessages) {
+  const appState = context.getAppState();
+  const defaultSysPrompt = await getSystemPrompt(context.options.tools, context.options.mainLoopModel, Array.from(appState.toolPermissionContext.additionalWorkingDirectories.keys()), context.options.mcpClients);
+  const systemPrompt = buildEffectiveSystemPrompt({
+    mainThreadAgentDefinition: undefined,
+    toolUseContext: context,
+    customSystemPrompt: context.options.customSystemPrompt,
+    defaultSystemPrompt: defaultSysPrompt,
+    appendSystemPrompt: context.options.appendSystemPrompt
+  });
+  const [userContext, systemContext] = await Promise.all([
+    getUserContext(),
+    getSystemContext()
+  ]);
+  return {
+    systemPrompt,
+    userContext,
+    systemContext,
+    toolUseContext: context,
+    forkContextMessages
+  };
+}
+var reactiveCompact = null, call = async (args, context) => {
+  const { abortController } = context;
+  let { messages } = context;
+  messages = getMessagesAfterCompactBoundary(messages);
+  if (messages.length === 0) {
+    throw new Error("No messages to compact");
+  }
+  const customInstructions = args.trim();
+  try {
+    if (!customInstructions) {
+      const sessionMemoryResult = await trySessionMemoryCompaction(messages, context.agentId);
+      if (sessionMemoryResult) {
+        getUserContext.cache.clear?.();
+        runPostCompactCleanup();
+        if (false) {}
+        markPostCompaction();
+        suppressCompactWarning();
+        return {
+          type: "compact",
+          compactionResult: sessionMemoryResult,
+          displayText: buildDisplayText(context)
+        };
+      }
+    }
+    if (reactiveCompact?.isReactiveOnlyMode()) {
+      return await compactViaReactive(messages, context, customInstructions, reactiveCompact);
+    }
+    const microcompactResult = await microcompactMessages(messages, context);
+    const messagesForCompact = microcompactResult.messages;
+    const result = await compactConversation(messagesForCompact, context, await getCacheSharingParams(context, messagesForCompact), false, customInstructions, false);
+    setLastSummarizedMessageId(undefined);
+    suppressCompactWarning();
+    getUserContext.cache.clear?.();
+    runPostCompactCleanup();
+    return {
+      type: "compact",
+      compactionResult: result,
+      displayText: buildDisplayText(context, result.userDisplayMessage)
+    };
+  } catch (error) {
+    if (abortController.signal.aborted) {
+      throw new Error("Compaction canceled.");
+    } else if (hasExactErrorMessage(error, ERROR_MESSAGE_NOT_ENOUGH_MESSAGES)) {
+      throw new Error(ERROR_MESSAGE_NOT_ENOUGH_MESSAGES);
+    } else if (hasExactErrorMessage(error, ERROR_MESSAGE_INCOMPLETE_RESPONSE)) {
+      throw new Error(ERROR_MESSAGE_INCOMPLETE_RESPONSE);
+    } else {
+      logError(error);
+      throw new Error(`Error during compaction: ${error}`);
+    }
+  }
+};
+var init_compact2 = __esm(() => {
+  init_source();
+  init_state();
+  init_prompts();
+  init_context();
+  init_shortcutFormat();
+  init_promptCacheBreakDetection();
+  init_compact();
+  init_compactWarningState();
+  init_microCompact();
+  init_postCompactCleanup();
+  init_sessionMemoryCompact();
+  init_sessionMemoryUtils();
+  init_errors();
+  init_hooks();
+  init_log();
+  init_messages();
+  init_contextWindowUpgradeCheck();
+  init_systemPrompt();
+});
+init_compact2();
+
+export {
+  call
+};

package/dist/chunk-mhc4szw7.js

@@ -0,0 +1,22 @@
+// @bun
+import {
+  require_lib
+} from "./chunk-1ztm9yps.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-eta5aekm.js";
+
+// node_modules/.bun/highlight.js@11.11.1/node_modules/highlight.js/es/index.js
+var import_lib, es_default;
+var init_es = __esm(() => {
+  import_lib = __toESM(require_lib(), 1);
+  es_default = import_lib.default;
+});
+init_es();
+var export_HighlightJS = import_lib.default;
+
+export {
+  es_default as default,
+  export_HighlightJS as HighlightJS
+};

package/dist/chunk-mkq0yzp0.js

@@ -0,0 +1,38 @@
+// @bun
+import"./chunk-ycarry7d.js";
+import"./chunk-6xvyx1s9.js";
+import"./chunk-c20aqkz8.js";
+import"./chunk-20xqs3yk.js";
+import"./chunk-5ygxa3hr.js";
+import"./chunk-83kmfcjv.js";
+import"./chunk-ahj70tf0.js";
+import"./chunk-hwz6aq2m.js";
+import"./chunk-kkgav8dm.js";
+import"./chunk-mrrx3bmt.js";
+import"./chunk-7g8156qp.js";
+import"./chunk-rb8k68m7.js";
+import"./chunk-bq75gxjs.js";
+import"./chunk-ev5gxscq.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-eta5aekm.js";
+import {
+  require_sts
+} from "./chunk-e50ckbv0.js";
+import"./chunk-4y382mzd.js";
+import"./chunk-4px25pe0.js";
+
+// node_modules/.bun/@aws-sdk+credential-providers@3.1020.0/node_modules/@aws-sdk/credential-providers/dist-es/loadSts.js
+var import_sts;
+var init_loadSts = __esm(() => {
+  import_sts = __toESM(require_sts(), 1);
+});
+init_loadSts();
+var export_STSClient = import_sts.STSClient;
+var export_AssumeRoleCommand = import_sts.AssumeRoleCommand;
+
+export {
+  export_STSClient as STSClient,
+  export_AssumeRoleCommand as AssumeRoleCommand
+};