@redscope-ai/redscope 1.0.0

package/dist/chunk-470kmby4.js

@@ -0,0 +1,318 @@
+// @bun
+import {
+  exports_operations,
+  init_operations
+} from "./chunk-dz7nc6rf.js";
+import {
+  analyzeContextUsage,
+  exports_contextCollapse,
+  getMessagesAfterCompactBoundary,
+  init_analyzeContext,
+  init_contextCollapse,
+  init_messages1 as init_messages,
+  init_microCompact,
+  microcompactMessages
+} from "./chunk-gmdy2w3z.js";
+import {
+  getSourceDisplayName,
+  init_constants,
+  init_stringUtils,
+  plural
+} from "./chunk-eemjb825.js";
+import {
+  formatTokens,
+  init_format
+} from "./chunk-q1vrhh0q.js";
+import {
+  __esm,
+  __toCommonJS
+} from "./chunk-hhsxm2yr.js";
+
+// src/commands/context/context-noninteractive.ts
+async function collectContextData(context) {
+  const {
+    messages,
+    getAppState,
+    options: {
+      mainLoopModel,
+      tools,
+      agentDefinitions,
+      customSystemPrompt,
+      appendSystemPrompt
+    }
+  } = context;
+  let apiView = getMessagesAfterCompactBoundary(messages);
+  if (true) {
+    const { projectView } = (init_operations(), __toCommonJS(exports_operations));
+    apiView = projectView(apiView);
+  }
+  const { messages: compactedMessages } = await microcompactMessages(apiView);
+  const appState = getAppState();
+  return analyzeContextUsage(compactedMessages, mainLoopModel, async () => appState.toolPermissionContext, tools, agentDefinitions, undefined, { options: { customSystemPrompt, appendSystemPrompt } }, undefined, apiView);
+}
+async function call(_args, context) {
+  const data = await collectContextData(context);
+  return {
+    type: "text",
+    value: formatContextAsMarkdownTable(data)
+  };
+}
+function formatContextAsMarkdownTable(data) {
+  const {
+    categories,
+    totalTokens,
+    rawMaxTokens,
+    percentage,
+    model,
+    memoryFiles,
+    mcpTools,
+    agents,
+    skills,
+    messageBreakdown,
+    systemTools,
+    systemPromptSections
+  } = data;
+  let output = `## Context Usage
+
+`;
+  output += `**Model:** ${model}  
+`;
+  output += `**Tokens:** ${formatTokens(totalTokens)} / ${formatTokens(rawMaxTokens)} (${percentage}%)
+`;
+  if (true) {
+    const { getStats, isContextCollapseEnabled } = (init_contextCollapse(), __toCommonJS(exports_contextCollapse));
+    if (isContextCollapseEnabled()) {
+      const s = getStats();
+      const { health: h } = s;
+      const parts = [];
+      if (s.collapsedSpans > 0) {
+        parts.push(`${s.collapsedSpans} ${plural(s.collapsedSpans, "span")} summarized (${s.collapsedMessages} messages)`);
+      }
+      if (s.stagedSpans > 0)
+        parts.push(`${s.stagedSpans} staged`);
+      const summary = parts.length > 0 ? parts.join(", ") : h.totalSpawns > 0 ? `${h.totalSpawns} ${plural(h.totalSpawns, "spawn")}, nothing staged yet` : "waiting for first trigger";
+      output += `**Context strategy:** collapse (${summary})
+`;
+      if (h.totalErrors > 0) {
+        output += `**Collapse errors:** ${h.totalErrors}/${h.totalSpawns} spawns failed`;
+        if (h.lastError) {
+          output += ` (last: ${h.lastError.slice(0, 80)})`;
+        }
+        output += `
+`;
+      } else if (h.emptySpawnWarningEmitted) {
+        output += `**Collapse idle:** ${h.totalEmptySpawns} consecutive empty runs
+`;
+      }
+    }
+  }
+  output += `
+`;
+  const visibleCategories = categories.filter((cat) => cat.tokens > 0 && cat.name !== "Free space" && cat.name !== "Autocompact buffer");
+  if (visibleCategories.length > 0) {
+    output += `### Estimated usage by category
+
+`;
+    output += `| Category | Tokens | Percentage |
+`;
+    output += `|----------|--------|------------|
+`;
+    for (const cat of visibleCategories) {
+      const percentDisplay = (cat.tokens / rawMaxTokens * 100).toFixed(1);
+      output += `| ${cat.name} | ${formatTokens(cat.tokens)} | ${percentDisplay}% |
+`;
+    }
+    const freeSpaceCategory = categories.find((c) => c.name === "Free space");
+    if (freeSpaceCategory && freeSpaceCategory.tokens > 0) {
+      const percentDisplay = (freeSpaceCategory.tokens / rawMaxTokens * 100).toFixed(1);
+      output += `| Free space | ${formatTokens(freeSpaceCategory.tokens)} | ${percentDisplay}% |
+`;
+    }
+    const autocompactCategory = categories.find((c) => c.name === "Autocompact buffer");
+    if (autocompactCategory && autocompactCategory.tokens > 0) {
+      const percentDisplay = (autocompactCategory.tokens / rawMaxTokens * 100).toFixed(1);
+      output += `| Autocompact buffer | ${formatTokens(autocompactCategory.tokens)} | ${percentDisplay}% |
+`;
+    }
+    output += `
+`;
+  }
+  if (mcpTools.length > 0) {
+    output += `### MCP Tools
+
+`;
+    output += `| Tool | Server | Tokens |
+`;
+    output += `|------|--------|--------|
+`;
+    for (const tool of mcpTools) {
+      output += `| ${tool.name} | ${tool.serverName} | ${formatTokens(tool.tokens)} |
+`;
+    }
+    output += `
+`;
+  }
+  if (systemTools && systemTools.length > 0 && process.env.USER_TYPE === "ant") {
+    output += `### [ANT-ONLY] System Tools
+
+`;
+    output += `| Tool | Tokens |
+`;
+    output += `|------|--------|
+`;
+    for (const tool of systemTools) {
+      output += `| ${tool.name} | ${formatTokens(tool.tokens)} |
+`;
+    }
+    output += `
+`;
+  }
+  if (systemPromptSections && systemPromptSections.length > 0 && process.env.USER_TYPE === "ant") {
+    output += `### [ANT-ONLY] System Prompt Sections
+
+`;
+    output += `| Section | Tokens |
+`;
+    output += `|---------|--------|
+`;
+    for (const section of systemPromptSections) {
+      output += `| ${section.name} | ${formatTokens(section.tokens)} |
+`;
+    }
+    output += `
+`;
+  }
+  if (agents.length > 0) {
+    output += `### Custom Agents
+
+`;
+    output += `| Agent Type | Source | Tokens |
+`;
+    output += `|------------|--------|--------|
+`;
+    for (const agent of agents) {
+      let sourceDisplay;
+      switch (agent.source) {
+        case "projectSettings":
+          sourceDisplay = "Project";
+          break;
+        case "userSettings":
+          sourceDisplay = "User";
+          break;
+        case "localSettings":
+          sourceDisplay = "Local";
+          break;
+        case "flagSettings":
+          sourceDisplay = "Flag";
+          break;
+        case "policySettings":
+          sourceDisplay = "Policy";
+          break;
+        case "plugin":
+          sourceDisplay = "Plugin";
+          break;
+        case "built-in":
+          sourceDisplay = "Built-in";
+          break;
+        default:
+          sourceDisplay = String(agent.source);
+      }
+      output += `| ${agent.agentType} | ${sourceDisplay} | ${formatTokens(agent.tokens)} |
+`;
+    }
+    output += `
+`;
+  }
+  if (memoryFiles.length > 0) {
+    output += `### Memory Files
+
+`;
+    output += `| Type | Path | Tokens |
+`;
+    output += `|------|------|--------|
+`;
+    for (const file of memoryFiles) {
+      output += `| ${file.type} | ${file.path} | ${formatTokens(file.tokens)} |
+`;
+    }
+    output += `
+`;
+  }
+  if (skills && skills.tokens > 0 && skills.skillFrontmatter.length > 0) {
+    output += `### Skills
+
+`;
+    output += `| Skill | Source | Tokens |
+`;
+    output += `|-------|--------|--------|
+`;
+    for (const skill of skills.skillFrontmatter) {
+      output += `| ${skill.name} | ${getSourceDisplayName(skill.source)} | ${formatTokens(skill.tokens)} |
+`;
+    }
+    output += `
+`;
+  }
+  if (messageBreakdown && process.env.USER_TYPE === "ant") {
+    output += `### [ANT-ONLY] Message Breakdown
+
+`;
+    output += `| Category | Tokens |
+`;
+    output += `|----------|--------|
+`;
+    output += `| Tool calls | ${formatTokens(messageBreakdown.toolCallTokens)} |
+`;
+    output += `| Tool results | ${formatTokens(messageBreakdown.toolResultTokens)} |
+`;
+    output += `| Attachments | ${formatTokens(messageBreakdown.attachmentTokens)} |
+`;
+    output += `| Assistant messages (non-tool) | ${formatTokens(messageBreakdown.assistantMessageTokens)} |
+`;
+    output += `| User messages (non-tool-result) | ${formatTokens(messageBreakdown.userMessageTokens)} |
+`;
+    output += `
+`;
+    if (messageBreakdown.toolCallsByType.length > 0) {
+      output += `#### Top Tools
+
+`;
+      output += `| Tool | Call Tokens | Result Tokens |
+`;
+      output += `|------|-------------|---------------|
+`;
+      for (const tool of messageBreakdown.toolCallsByType) {
+        output += `| ${tool.name} | ${formatTokens(tool.callTokens)} | ${formatTokens(tool.resultTokens)} |
+`;
+      }
+      output += `
+`;
+    }
+    if (messageBreakdown.attachmentsByType.length > 0) {
+      output += `#### Top Attachments
+
+`;
+      output += `| Attachment | Tokens |
+`;
+      output += `|------------|--------|
+`;
+      for (const attachment of messageBreakdown.attachmentsByType) {
+        output += `| ${attachment.name} | ${formatTokens(attachment.tokens)} |
+`;
+      }
+      output += `
+`;
+    }
+  }
+  return output;
+}
+var init_context_noninteractive = __esm(() => {
+  init_microCompact();
+  init_analyzeContext();
+  init_format();
+  init_messages();
+  init_constants();
+  init_stringUtils();
+});
+
+export { collectContextData, call, init_context_noninteractive };

package/dist/chunk-47jc141z.js

@@ -0,0 +1,335 @@
+// @bun
+import {
+  DEFAULT_SESSION_MEMORY_CONFIG,
+  FILE_EDIT_TOOL_NAME,
+  FileReadTool,
+  buildSessionMemoryUpdatePrompt,
+  createCacheSafeParams,
+  createSubagentContext,
+  createUserMessage,
+  getSessionMemoryConfig,
+  getSessionMemoryDir,
+  getSessionMemoryPath,
+  getSystemContext,
+  getSystemPrompt,
+  getTokenUsage,
+  getToolCallsBetweenUpdates,
+  getUserContext,
+  hasMetInitializationThreshold,
+  hasMetUpdateThreshold,
+  hasToolCallsInLastAssistantTurn,
+  init_FileReadTool,
+  init_autoCompact,
+  init_constants,
+  init_context,
+  init_filesystem,
+  init_forkedAgent,
+  init_messages1 as init_messages,
+  init_postSamplingHooks,
+  init_prompts,
+  init_prompts1 as init_prompts2,
+  init_sessionMemoryUtils,
+  init_systemPromptType,
+  init_tokens,
+  isAutoCompactEnabled,
+  isSessionMemoryInitialized,
+  loadSessionMemoryTemplate,
+  markExtractionCompleted,
+  markExtractionStarted,
+  markSessionMemoryInitialized,
+  recordExtractionTokenCount,
+  registerPostSamplingHook,
+  runForkedAgent,
+  setLastSummarizedMessageId,
+  setSessionMemoryConfig,
+  tokenCountWithEstimation
+} from "./chunk-gmdy2w3z.js";
+import {
+  asSystemPrompt
+} from "./chunk-nzxfj0gq.js";
+import {
+  getDynamicConfig_CACHED_MAY_BE_STALE,
+  getFeatureValue_CACHED_MAY_BE_STALE,
+  init_growthbook,
+  init_sequential,
+  sequential
+} from "./chunk-eemjb825.js";
+import {
+  count,
+  init_array
+} from "./chunk-k7hexw3v.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-j1mep9ck.js";
+import {
+  errorMessage,
+  getErrnoCode,
+  getFsImplementation,
+  init_errors,
+  init_fsOperations
+} from "./chunk-s3hafnk3.js";
+import {
+  getIsRemoteMode,
+  init_memoize,
+  init_state,
+  memoize_default
+} from "./chunk-9h9k5vz3.js";
+import {
+  __esm,
+  __require
+} from "./chunk-hhsxm2yr.js";
+
+// src/services/SessionMemory/sessionMemory.ts
+import { writeFile } from "fs/promises";
+function isSessionMemoryGateEnabled() {
+  return getFeatureValue_CACHED_MAY_BE_STALE("tengu_session_memory", false);
+}
+function getSessionMemoryRemoteConfig() {
+  return getDynamicConfig_CACHED_MAY_BE_STALE("tengu_sm_config", {});
+}
+function resetLastMemoryMessageUuid() {
+  lastMemoryMessageUuid = undefined;
+}
+function countToolCallsSince(messages, sinceUuid) {
+  let toolCallCount = 0;
+  let foundStart = sinceUuid === null || sinceUuid === undefined;
+  for (const message of messages) {
+    if (!foundStart) {
+      if (message.uuid === sinceUuid) {
+        foundStart = true;
+      }
+      continue;
+    }
+    if (message.type === "assistant") {
+      const content = message.message.content;
+      if (Array.isArray(content)) {
+        toolCallCount += count(content, (block) => block.type === "tool_use");
+      }
+    }
+  }
+  return toolCallCount;
+}
+function shouldExtractMemory(messages) {
+  const currentTokenCount = tokenCountWithEstimation(messages);
+  if (!isSessionMemoryInitialized()) {
+    if (!hasMetInitializationThreshold(currentTokenCount)) {
+      return false;
+    }
+    markSessionMemoryInitialized();
+  }
+  const hasMetTokenThreshold = hasMetUpdateThreshold(currentTokenCount);
+  const toolCallsSinceLastUpdate = countToolCallsSince(messages, lastMemoryMessageUuid);
+  const hasMetToolCallThreshold = toolCallsSinceLastUpdate >= getToolCallsBetweenUpdates();
+  const hasToolCallsInLastTurn = hasToolCallsInLastAssistantTurn(messages);
+  const shouldExtract = hasMetTokenThreshold && hasMetToolCallThreshold || hasMetTokenThreshold && !hasToolCallsInLastTurn;
+  if (shouldExtract) {
+    const lastMessage = messages[messages.length - 1];
+    if (lastMessage?.uuid) {
+      lastMemoryMessageUuid = lastMessage.uuid;
+    }
+    return true;
+  }
+  return false;
+}
+async function setupSessionMemoryFile(toolUseContext) {
+  const fs = getFsImplementation();
+  const sessionMemoryDir = getSessionMemoryDir();
+  await fs.mkdir(sessionMemoryDir, { mode: 448 });
+  const memoryPath = getSessionMemoryPath();
+  try {
+    await writeFile(memoryPath, "", {
+      encoding: "utf-8",
+      mode: 384,
+      flag: "wx"
+    });
+    const template = await loadSessionMemoryTemplate();
+    await writeFile(memoryPath, template, {
+      encoding: "utf-8",
+      mode: 384
+    });
+  } catch (e) {
+    const code = getErrnoCode(e);
+    if (code !== "EEXIST") {
+      throw e;
+    }
+  }
+  toolUseContext.readFileState.delete(memoryPath);
+  const result = await FileReadTool.call({ file_path: memoryPath }, toolUseContext);
+  let currentMemory = "";
+  const output = result.data;
+  if (output.type === "text") {
+    currentMemory = output.file.content;
+  }
+  logEvent("tengu_session_memory_file_read", {
+    content_length: currentMemory.length
+  });
+  return { memoryPath, currentMemory };
+}
+function initSessionMemory() {
+  if (getIsRemoteMode())
+    return;
+  const autoCompactEnabled = isAutoCompactEnabled();
+  if (process.env.USER_TYPE === "ant") {
+    logEvent("tengu_session_memory_init", {
+      auto_compact_enabled: autoCompactEnabled
+    });
+  }
+  if (!autoCompactEnabled) {
+    return;
+  }
+  registerPostSamplingHook(extractSessionMemory);
+}
+async function manuallyExtractSessionMemory(messages, toolUseContext) {
+  if (messages.length === 0) {
+    return { success: false, error: "No messages to summarize" };
+  }
+  markExtractionStarted();
+  try {
+    const setupContext = createSubagentContext(toolUseContext);
+    const { memoryPath, currentMemory } = await setupSessionMemoryFile(setupContext);
+    const userPrompt = await buildSessionMemoryUpdatePrompt(currentMemory, memoryPath);
+    const { tools, mainLoopModel } = toolUseContext.options;
+    const [rawSystemPrompt, userContext, systemContext] = await Promise.all([
+      getSystemPrompt(tools, mainLoopModel),
+      getUserContext(),
+      getSystemContext()
+    ]);
+    const systemPrompt = asSystemPrompt(rawSystemPrompt);
+    await runForkedAgent({
+      promptMessages: [createUserMessage({ content: userPrompt })],
+      cacheSafeParams: {
+        systemPrompt,
+        userContext,
+        systemContext,
+        toolUseContext: setupContext,
+        forkContextMessages: messages
+      },
+      canUseTool: createMemoryFileCanUseTool(memoryPath),
+      querySource: "session_memory",
+      forkLabel: "session_memory_manual",
+      overrides: { readFileState: setupContext.readFileState }
+    });
+    logEvent("tengu_session_memory_manual_extraction", {});
+    recordExtractionTokenCount(tokenCountWithEstimation(messages));
+    updateLastSummarizedMessageIdIfSafe(messages);
+    return { success: true, memoryPath };
+  } catch (error) {
+    return {
+      success: false,
+      error: errorMessage(error)
+    };
+  } finally {
+    markExtractionCompleted();
+  }
+}
+function createMemoryFileCanUseTool(memoryPath) {
+  return async (tool, input) => {
+    if (tool.name === FILE_EDIT_TOOL_NAME && typeof input === "object" && input !== null && "file_path" in input) {
+      const filePath = input.file_path;
+      if (typeof filePath === "string" && filePath === memoryPath) {
+        return { behavior: "allow", updatedInput: input };
+      }
+    }
+    return {
+      behavior: "deny",
+      message: `only ${FILE_EDIT_TOOL_NAME} on ${memoryPath} is allowed`,
+      decisionReason: {
+        type: "other",
+        reason: `only ${FILE_EDIT_TOOL_NAME} on ${memoryPath} is allowed`
+      }
+    };
+  };
+}
+function updateLastSummarizedMessageIdIfSafe(messages) {
+  if (!hasToolCallsInLastAssistantTurn(messages)) {
+    const lastMessage = messages[messages.length - 1];
+    if (lastMessage?.uuid) {
+      setLastSummarizedMessageId(lastMessage.uuid);
+    }
+  }
+}
+var lastMemoryMessageUuid, initSessionMemoryConfigIfNeeded, hasLoggedGateFailure = false, extractSessionMemory;
+var init_sessionMemory = __esm(() => {
+  init_memoize();
+  init_state();
+  init_prompts2();
+  init_context();
+  init_constants();
+  init_FileReadTool();
+  init_array();
+  init_forkedAgent();
+  init_fsOperations();
+  init_postSamplingHooks();
+  init_messages();
+  init_filesystem();
+  init_sequential();
+  init_systemPromptType();
+  init_tokens();
+  init_analytics();
+  init_autoCompact();
+  init_prompts();
+  init_sessionMemoryUtils();
+  init_errors();
+  init_growthbook();
+  initSessionMemoryConfigIfNeeded = memoize_default(() => {
+    const remoteConfig = getSessionMemoryRemoteConfig();
+    const config = {
+      minimumMessageTokensToInit: remoteConfig.minimumMessageTokensToInit && remoteConfig.minimumMessageTokensToInit > 0 ? remoteConfig.minimumMessageTokensToInit : DEFAULT_SESSION_MEMORY_CONFIG.minimumMessageTokensToInit,
+      minimumTokensBetweenUpdate: remoteConfig.minimumTokensBetweenUpdate && remoteConfig.minimumTokensBetweenUpdate > 0 ? remoteConfig.minimumTokensBetweenUpdate : DEFAULT_SESSION_MEMORY_CONFIG.minimumTokensBetweenUpdate,
+      toolCallsBetweenUpdates: remoteConfig.toolCallsBetweenUpdates && remoteConfig.toolCallsBetweenUpdates > 0 ? remoteConfig.toolCallsBetweenUpdates : DEFAULT_SESSION_MEMORY_CONFIG.toolCallsBetweenUpdates
+    };
+    setSessionMemoryConfig(config);
+  });
+  extractSessionMemory = sequential(async function(context) {
+    const { messages, toolUseContext, querySource } = context;
+    if (querySource !== "repl_main_thread") {
+      return;
+    }
+    if (true) {
+      const { isPoorModeActive } = await import("./chunk-ag81m9bq.js");
+      if (isPoorModeActive())
+        return;
+    }
+    if (!isSessionMemoryGateEnabled()) {
+      if (process.env.USER_TYPE === "ant" && !hasLoggedGateFailure) {
+        hasLoggedGateFailure = true;
+        logEvent("tengu_session_memory_gate_disabled", {});
+      }
+      return;
+    }
+    initSessionMemoryConfigIfNeeded();
+    if (!shouldExtractMemory(messages)) {
+      return;
+    }
+    markExtractionStarted();
+    const setupContext = createSubagentContext(toolUseContext);
+    const { memoryPath, currentMemory } = await setupSessionMemoryFile(setupContext);
+    const userPrompt = await buildSessionMemoryUpdatePrompt(currentMemory, memoryPath);
+    await runForkedAgent({
+      promptMessages: [createUserMessage({ content: userPrompt })],
+      cacheSafeParams: createCacheSafeParams(context),
+      canUseTool: createMemoryFileCanUseTool(memoryPath),
+      querySource: "session_memory",
+      forkLabel: "session_memory",
+      overrides: { readFileState: setupContext.readFileState }
+    });
+    const lastMessage = messages[messages.length - 1];
+    const usage = lastMessage ? getTokenUsage(lastMessage) : undefined;
+    const config = getSessionMemoryConfig();
+    logEvent("tengu_session_memory_extraction", {
+      input_tokens: usage?.input_tokens,
+      output_tokens: usage?.output_tokens,
+      cache_read_input_tokens: usage?.cache_read_input_tokens ?? undefined,
+      cache_creation_input_tokens: usage?.cache_creation_input_tokens ?? undefined,
+      config_min_message_tokens_to_init: config.minimumMessageTokensToInit,
+      config_min_tokens_between_update: config.minimumTokensBetweenUpdate,
+      config_tool_calls_between_updates: config.toolCallsBetweenUpdates
+    });
+    recordExtractionTokenCount(tokenCountWithEstimation(messages));
+    updateLastSummarizedMessageIdIfSafe(messages);
+    markExtractionCompleted();
+  });
+});
+
+export { resetLastMemoryMessageUuid, shouldExtractMemory, initSessionMemory, manuallyExtractSessionMemory, createMemoryFileCanUseTool, init_sessionMemory };