jialing-code 1.1.0

package/dist/chunk-5pen7vr8.js

@@ -0,0 +1,176 @@
+// @bun
+import {
+  init_sink,
+  initializeAnalyticsSink
+} from "./chunk-3m84sret.js";
+import {
+  CACHE_PATHS,
+  attachErrorLogSink,
+  dateToFilename,
+  init_cachePaths,
+  init_log
+} from "./chunk-p7g7pf3f.js";
+import {
+  createBufferedWriter,
+  getFsImplementation,
+  init_bufferedWriter,
+  init_cleanupRegistry,
+  init_debug,
+  init_fsOperations,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging,
+  registerCleanup
+} from "./chunk-nxsh6de2.js";
+import {
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-xszk7n10.js";
+
+// src/utils/sinks.ts
+init_sink();
+
+// src/utils/errorLogSink.ts
+init_axios();
+init_state();
+init_bufferedWriter();
+init_cachePaths();
+init_cleanupRegistry();
+init_debug();
+init_fsOperations();
+init_log();
+init_slowOperations();
+import { dirname, join } from "path";
+var DATE = dateToFilename(new Date);
+function getErrorsPath() {
+  return join(CACHE_PATHS.errors(), DATE + ".jsonl");
+}
+function getMCPLogsPath(serverName) {
+  return join(CACHE_PATHS.mcpLogs(serverName), DATE + ".jsonl");
+}
+function createJsonlWriter(options) {
+  const writer = createBufferedWriter(options);
+  return {
+    write(obj) {
+      writer.write(jsonStringify(obj) + `
+`);
+    },
+    flush: writer.flush,
+    dispose: writer.dispose
+  };
+}
+var logWriters = new Map;
+function getLogWriter(path) {
+  let writer = logWriters.get(path);
+  if (!writer) {
+    const dir = dirname(path);
+    writer = createJsonlWriter({
+      writeFn: (content) => {
+        try {
+          getFsImplementation().appendFileSync(path, content);
+        } catch {
+          getFsImplementation().mkdirSync(dir);
+          getFsImplementation().appendFileSync(path, content);
+        }
+      },
+      flushIntervalMs: 1000,
+      maxBufferSize: 50
+    });
+    logWriters.set(path, writer);
+    registerCleanup(async () => writer?.dispose());
+  }
+  return writer;
+}
+function appendToLog(path, message) {
+  if (process.env.USER_TYPE !== "ant") {
+    return;
+  }
+  const messageWithTimestamp = {
+    timestamp: new Date().toISOString(),
+    ...message,
+    cwd: getFsImplementation().cwd(),
+    userType: process.env.USER_TYPE,
+    sessionId: getSessionId(),
+    version: MACRO.VERSION
+  };
+  getLogWriter(path).write(messageWithTimestamp);
+}
+function extractServerMessage(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (data && typeof data === "object") {
+    const obj = data;
+    if (typeof obj.message === "string") {
+      return obj.message;
+    }
+    if (typeof obj.error === "object" && obj.error && "message" in obj.error && typeof obj.error.message === "string") {
+      return obj.error.message;
+    }
+  }
+  return;
+}
+function logErrorImpl(error) {
+  const errorStr = error.stack || error.message;
+  let context = "";
+  if (axios_default.isAxiosError(error) && error.config?.url) {
+    const parts = [`url=${error.config.url}`];
+    if (error.response?.status !== undefined) {
+      parts.push(`status=${error.response.status}`);
+    }
+    const serverMessage = extractServerMessage(error.response?.data);
+    if (serverMessage) {
+      parts.push(`body=${serverMessage}`);
+    }
+    context = `[${parts.join(",")}] `;
+  }
+  logForDebugging(`${error.name}: ${context}${errorStr}`, { level: "error" });
+  appendToLog(getErrorsPath(), {
+    error: `${context}${errorStr}`
+  });
+}
+function logMCPErrorImpl(serverName, error) {
+  logForDebugging(`MCP server "${serverName}" ${error}`, { level: "error" });
+  const logFile = getMCPLogsPath(serverName);
+  const errorStr = error instanceof Error ? error.stack || error.message : String(error);
+  const errorInfo = {
+    error: errorStr,
+    timestamp: new Date().toISOString(),
+    sessionId: getSessionId(),
+    cwd: getFsImplementation().cwd()
+  };
+  getLogWriter(logFile).write(errorInfo);
+}
+function logMCPDebugImpl(serverName, message) {
+  logForDebugging(`MCP server "${serverName}": ${message}`);
+  const logFile = getMCPLogsPath(serverName);
+  const debugInfo = {
+    debug: message,
+    timestamp: new Date().toISOString(),
+    sessionId: getSessionId(),
+    cwd: getFsImplementation().cwd()
+  };
+  getLogWriter(logFile).write(debugInfo);
+}
+function initializeErrorLogSink() {
+  attachErrorLogSink({
+    logError: logErrorImpl,
+    logMCPError: logMCPErrorImpl,
+    logMCPDebug: logMCPDebugImpl,
+    getErrorsPath,
+    getMCPLogsPath
+  });
+  logForDebugging("Error log sink initialized");
+}
+
+// src/utils/sinks.ts
+function initSinks() {
+  initializeErrorLogSink();
+  initializeAnalyticsSink();
+}
+
+export { initSinks };

package/dist/chunk-5r280eng.js

@@ -0,0 +1,198 @@
+// @bun
+import {
+  clearSessionCaches,
+  init_caches
+} from "./chunk-nnaxkc2z.js";
+import {
+  asAgentId,
+  clearAllPlanSlugs,
+  clearSessionMetadata,
+  evictTaskOutput,
+  executeSessionEndHooks,
+  getAgentTranscriptPath,
+  getCurrentWorktreeSession,
+  getSessionEndHookTimeoutMs,
+  initTaskOutputAsSymlink,
+  init_LocalAgentTask,
+  init_Shell,
+  init_diskOutput,
+  init_guards,
+  init_hooks1 as init_hooks,
+  init_ids,
+  init_plans,
+  init_sessionStart,
+  init_sessionStorage,
+  init_types1 as init_types,
+  init_worktree,
+  isInProcessTeammateTask,
+  isLocalAgentTask,
+  isLocalShellTask,
+  processSessionStartHooks,
+  resetSessionFilePointer,
+  saveWorktreeState,
+  setCwd
+} from "./chunk-ewsgsw9h.js";
+import {
+  createEmptyAttributionState,
+  init_commitAttribution
+} from "./chunk-z1zj044v.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-f2mhrmww.js";
+import {
+  init_log,
+  logError
+} from "./chunk-p7g7pf3f.js";
+import {
+  getLastMainRequestId,
+  getOriginalCwd,
+  getSessionId,
+  init_state,
+  regenerateSessionId
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/clear/conversation.ts
+import { randomUUID } from "crypto";
+async function clearConversation({
+  setMessages,
+  readFileState,
+  discoveredSkillNames,
+  loadedNestedMemoryPaths,
+  getAppState,
+  setAppState,
+  setConversationId
+}) {
+  const sessionEndTimeoutMs = getSessionEndHookTimeoutMs();
+  await executeSessionEndHooks("clear", {
+    getAppState,
+    setAppState,
+    signal: AbortSignal.timeout(sessionEndTimeoutMs),
+    timeoutMs: sessionEndTimeoutMs
+  });
+  const lastRequestId = getLastMainRequestId();
+  if (lastRequestId) {
+    logEvent("tengu_cache_eviction_hint", {
+      scope: "conversation_clear",
+      last_request_id: lastRequestId
+    });
+  }
+  const preservedAgentIds = new Set;
+  const preservedLocalAgents = [];
+  const shouldKillTask = (task) => ("isBackgrounded" in task) && task.isBackgrounded === false;
+  if (getAppState) {
+    for (const task of Object.values(getAppState().tasks)) {
+      if (shouldKillTask(task))
+        continue;
+      if (isLocalAgentTask(task)) {
+        preservedAgentIds.add(task.agentId);
+        preservedLocalAgents.push(task);
+      } else if (isInProcessTeammateTask(task)) {
+        preservedAgentIds.add(task.identity.agentId);
+      }
+    }
+  }
+  setMessages(() => []);
+  if (false) {}
+  if (setConversationId) {
+    setConversationId(randomUUID());
+  }
+  clearSessionCaches(preservedAgentIds);
+  setCwd(getOriginalCwd());
+  readFileState.clear();
+  discoveredSkillNames?.clear();
+  loadedNestedMemoryPaths?.clear();
+  if (setAppState) {
+    setAppState((prev) => {
+      const nextTasks = {};
+      for (const [taskId, task] of Object.entries(prev.tasks)) {
+        if (!shouldKillTask(task)) {
+          nextTasks[taskId] = task;
+          continue;
+        }
+        try {
+          if (task.status === "running") {
+            if (isLocalShellTask(task)) {
+              task.shellCommand?.kill();
+              task.shellCommand?.cleanup();
+              if (task.cleanupTimeoutId) {
+                clearTimeout(task.cleanupTimeoutId);
+              }
+            }
+            if ("abortController" in task) {
+              task.abortController?.abort();
+            }
+            if ("unregisterCleanup" in task) {
+              task.unregisterCleanup?.();
+            }
+          }
+        } catch (error) {
+          logError(error);
+        }
+        evictTaskOutput(taskId);
+      }
+      return {
+        ...prev,
+        tasks: nextTasks,
+        attribution: createEmptyAttributionState(),
+        standaloneAgentContext: undefined,
+        fileHistory: {
+          snapshots: [],
+          trackedFiles: new Set,
+          snapshotSequence: 0
+        },
+        mcp: {
+          clients: [],
+          tools: [],
+          commands: [],
+          resources: {},
+          pluginReconnectKey: prev.mcp.pluginReconnectKey
+        }
+      };
+    });
+  }
+  clearAllPlanSlugs();
+  clearSessionMetadata();
+  regenerateSessionId({ setCurrentAsParent: true });
+  if (process.env.USER_TYPE === "ant" && process.env.CLAUDE_CODE_SESSION_ID) {
+    process.env.CLAUDE_CODE_SESSION_ID = getSessionId();
+  }
+  await resetSessionFilePointer();
+  for (const task of preservedLocalAgents) {
+    if (task.status !== "running")
+      continue;
+    initTaskOutputAsSymlink(task.id, getAgentTranscriptPath(asAgentId(task.agentId)));
+  }
+  if (false) {}
+  const worktreeSession = getCurrentWorktreeSession();
+  if (worktreeSession) {
+    saveWorktreeState(worktreeSession);
+  }
+  const hookMessages = await processSessionStartHooks("clear");
+  if (hookMessages.length > 0) {
+    setMessages(() => hookMessages);
+  }
+}
+var init_conversation = __esm(() => {
+  init_state();
+  init_analytics();
+  init_types();
+  init_LocalAgentTask();
+  init_guards();
+  init_ids();
+  init_commitAttribution();
+  init_hooks();
+  init_log();
+  init_plans();
+  init_Shell();
+  init_sessionStart();
+  init_sessionStorage();
+  init_diskOutput();
+  init_worktree();
+  init_caches();
+});
+
+export { clearConversation, init_conversation };

package/dist/chunk-5srym52s.js

@@ -0,0 +1,88 @@
+// @bun
+import {
+  checkGate_CACHED_OR_BLOCKING,
+  checkSecurityRestrictionGate,
+  checkStatsigFeatureGate_CACHED_MAY_BE_STALE,
+  clearGrowthBookConfigOverrides,
+  getAllGrowthBookFeatures,
+  getApiBaseUrlHost,
+  getDynamicConfig_BLOCKS_ON_INIT,
+  getDynamicConfig_CACHED_MAY_BE_STALE,
+  getFeatureValue_CACHED_MAY_BE_STALE,
+  getFeatureValue_CACHED_WITH_REFRESH,
+  getFeatureValue_DEPRECATED,
+  getGrowthBookConfigOverrides,
+  hasGrowthBookEnvOverride,
+  init_growthbook,
+  initializeGrowthBook,
+  onGrowthBookRefresh,
+  refreshGrowthBookAfterAuthChange,
+  refreshGrowthBookFeatures,
+  resetGrowthBook,
+  setGrowthBookConfigOverride,
+  setupPeriodicGrowthBookRefresh,
+  stopPeriodicGrowthBookRefresh
+} from "./chunk-3f7rypmf.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-vratq94g.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-6kpbgc5w.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-tjaqa99q.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-w2z5pqd3.js";
+import"./chunk-7ymfj7m3.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-1eapde8a.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-1rvz0433.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-hrzerbfw.js";
+import"./chunk-d18z9pna.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-hjhc4cpt.js";
+import"./chunk-vyc0rjyx.js";
+import"./chunk-hx2tr4ep.js";
+import"./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import"./chunk-qp2qdcda.js";
+init_growthbook();
+
+export {
+  stopPeriodicGrowthBookRefresh,
+  setupPeriodicGrowthBookRefresh,
+  setGrowthBookConfigOverride,
+  resetGrowthBook,
+  refreshGrowthBookFeatures,
+  refreshGrowthBookAfterAuthChange,
+  onGrowthBookRefresh,
+  initializeGrowthBook,
+  hasGrowthBookEnvOverride,
+  getGrowthBookConfigOverrides,
+  getFeatureValue_DEPRECATED,
+  getFeatureValue_CACHED_WITH_REFRESH,
+  getFeatureValue_CACHED_MAY_BE_STALE,
+  getDynamicConfig_CACHED_MAY_BE_STALE,
+  getDynamicConfig_BLOCKS_ON_INIT,
+  getApiBaseUrlHost,
+  getAllGrowthBookFeatures,
+  clearGrowthBookConfigOverrides,
+  checkStatsigFeatureGate_CACHED_MAY_BE_STALE,
+  checkSecurityRestrictionGate,
+  checkGate_CACHED_OR_BLOCKING
+};

package/dist/chunk-600kg7k6.js

@@ -0,0 +1,41 @@
+// @bun
+import {
+  require_src as require_src3
+} from "./chunk-xk7zaqta.js";
+import {
+  require_src,
+  require_src1 as require_src2
+} from "./chunk-90wp6wez.js";
+import"./chunk-a8ejc632.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import {
+  __commonJS
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@opentelemetry+exporter-logs-otlp-grpc@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-logs-otlp-grpc/build/src/OTLPLogExporter.js
+var require_OTLPLogExporter = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPLogExporter = undefined;
+  var otlp_grpc_exporter_base_1 = require_src3();
+  var otlp_transformer_1 = require_src2();
+  var otlp_exporter_base_1 = require_src();
+
+  class OTLPLogExporter extends otlp_exporter_base_1.OTLPExporterBase {
+    constructor(config = {}) {
+      super((0, otlp_grpc_exporter_base_1.createOtlpGrpcExportDelegate)((0, otlp_grpc_exporter_base_1.convertLegacyOtlpGrpcOptions)(config, "LOGS"), otlp_transformer_1.ProtobufLogsSerializer, "LogsExportService", "/opentelemetry.proto.collector.logs.v1.LogsService/Export"));
+    }
+  }
+  exports.OTLPLogExporter = OTLPLogExporter;
+});
+
+// node_modules/.bun/@opentelemetry+exporter-logs-otlp-grpc@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-logs-otlp-grpc/build/src/index.js
+var require_src4 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPLogExporter = undefined;
+  var OTLPLogExporter_1 = require_OTLPLogExporter();
+  Object.defineProperty(exports, "OTLPLogExporter", { enumerable: true, get: function() {
+    return OTLPLogExporter_1.OTLPLogExporter;
+  } });
+});
+export default require_src4();

package/dist/chunk-616w0qj3.js

@@ -0,0 +1,160 @@
+// @bun
+import {
+  require_compiler_runtime
+} from "./chunk-s9mesaw0.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  init_config1 as init_config,
+  saveCurrentProjectConfig
+} from "./chunk-3f7rypmf.js";
+import {
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/context/stats.tsx
+init_config();
+var import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+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(t0) {
+  const $ = import_compiler_runtime.c(7);
+  const {
+    store: externalStore,
+    children
+  } = t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = createStatsStore();
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const internalStore = t1;
+  const store = externalStore ?? internalStore;
+  let t2;
+  let t3;
+  if ($[1] !== store) {
+    t2 = () => {
+      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);
+      };
+    };
+    t3 = [store];
+    $[1] = store;
+    $[2] = t2;
+    $[3] = t3;
+  } else {
+    t2 = $[2];
+    t3 = $[3];
+  }
+  import_react.useEffect(t2, t3);
+  let t4;
+  if ($[4] !== children || $[5] !== store) {
+    t4 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(StatsContext.Provider, {
+      value: store,
+      children
+    }, undefined, false, undefined, this);
+    $[4] = children;
+    $[5] = store;
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  return t4;
+}
+
+export { createStatsStore, StatsProvider };