feat: add Graphify context compression

AI-assisted: Jcode

Author: akvarel

crates/jcode-app-core/src/agent/tools.rs

@@ -4,7 +4,28 @@ use crate::tool::ToolOutput;
 
 pub(super) const MAX_TOOL_OUTPUT_CHARS_FOR_HISTORY: usize = 512 * 1024;
 
+fn graph_compact_tool_limit() -> Option<usize> {
+    let config = crate::config::config();
+    (config.context_compression.mode == crate::config::ContextCompressionMode::GraphCompact)
+        .then_some(config.context_compression.max_tool_output_chars)
+}
+
+fn compact_tool_output_if_enabled(tool_name: &str, content: &str) -> Option<String> {
+    let limit = graph_compact_tool_limit()?;
+    if content.chars().count() <= limit {
+        return None;
+    }
+    let store_root = crate::storage::jcode_dir().ok()?.join("context-store");
+    crate::context_compiler::store_and_compact_tool_output(tool_name, content, limit, &store_root)
+        .ok()
+        .map(|stored| stored.compact_content)
+}
+
 pub(super) fn cap_tool_output_for_history(tool_name: &str, mut output: ToolOutput) -> ToolOutput {
+    if let Some(compact) = compact_tool_output_if_enabled(tool_name, &output.output) {
+        output.output = compact;
+        return output;
+    }
     if output.output.chars().count() <= MAX_TOOL_OUTPUT_CHARS_FOR_HISTORY {
         return output;
     }
@@ -19,6 +40,9 @@ pub(super) fn cap_tool_output_for_history(tool_name: &str, mut output: ToolOutpu
 }
 
 pub(super) fn cap_sdk_tool_content_for_history(tool_name: &str, content: String) -> String {
+    if let Some(compact) = compact_tool_output_if_enabled(tool_name, &content) {
+        return compact;
+    }
     if content.chars().count() <= MAX_TOOL_OUTPUT_CHARS_FOR_HISTORY {
         return content;
     }

crates/jcode-base/examples/context_compression_eval.rs

@@ -0,0 +1,82 @@
+use jcode_base::context_compiler::{compile_graphify_context, estimate_tokens};
+use serde::Serialize;
+use std::process::Command;
+
+#[derive(Serialize)]
+struct EvaluationReport {
+    task: String,
+    baseline: Metrics,
+    graph_compact: Metrics,
+    input_compression_ratio: f64,
+    root_nodes_preserved: usize,
+}
+
+#[derive(Serialize)]
+struct Metrics {
+    context_bytes: usize,
+    context_tokens_estimated: usize,
+    context_items: usize,
+    compression_mode: &'static str,
+    compression_version: &'static str,
+}
+
+fn main() {
+    let task = std::env::args().skip(1).collect::<Vec<_>>().join(" ");
+    let task = if task.trim().is_empty() {
+        "messages_for_provider context compaction".to_string()
+    } else {
+        task
+    };
+    let budget = std::env::var("JCODE_CONTEXT_GRAPH_TOKEN_BUDGET")
+        .ok()
+        .and_then(|value| value.parse().ok())
+        .unwrap_or(1_200);
+    let max_items = std::env::var("JCODE_CONTEXT_MAX_GRAPH_ITEMS")
+        .ok()
+        .and_then(|value| value.parse().ok())
+        .unwrap_or(24);
+
+    let output = Command::new("graphify")
+        .args(["query", &task, "--format", "compact"])
+        .output()
+        .expect("graphify must be installed and available on PATH");
+    if !output.status.success() {
+        eprintln!(
+            "graphify query failed: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        std::process::exit(2);
+    }
+
+    let raw = String::from_utf8_lossy(&output.stdout);
+    let candidate_items = raw.lines().filter(|line| line.starts_with("NODE ")).count();
+    let compiled = compile_graphify_context(&task, &raw, budget, max_items);
+    let compiled_json = compiled.to_prompt_json();
+    let baseline_tokens = estimate_tokens(&raw);
+    let compressed_tokens = estimate_tokens(&compiled_json);
+    let report = EvaluationReport {
+        task,
+        baseline: Metrics {
+            context_bytes: raw.len(),
+            context_tokens_estimated: baseline_tokens,
+            context_items: candidate_items,
+            compression_mode: "off",
+            compression_version: "baseline",
+        },
+        graph_compact: Metrics {
+            context_bytes: compiled_json.len(),
+            context_tokens_estimated: compressed_tokens,
+            context_items: compiled.items.len(),
+            compression_mode: compiled.mode,
+            compression_version: compiled.version,
+        },
+        input_compression_ratio: if compressed_tokens == 0 {
+            0.0
+        } else {
+            baseline_tokens as f64 / compressed_tokens as f64
+        },
+        root_nodes_preserved: compiled.root_nodes.len(),
+    };
+
+    println!("{}", serde_json::to_string_pretty(&report).unwrap());
+}

crates/jcode-base/src/config.rs

@@ -5,14 +5,14 @@
 
 pub use jcode_config_types::{
     AgentsConfig, AmbientConfig, AuthConfig, AutoJudgeConfig, AutoReviewConfig, CompactionConfig,
-    CompactionMode, CrossProviderFailoverMode, DiagramDisplayMode, DiagramPanePosition,
-    DiffDisplayMode, DisplayConfig, FeatureConfig, GatewayConfig, HookCommands, HooksConfig,
-    KeybindingsConfig, LatexRenderingMode, LaunchHotkeyEntry, LaunchHotkeysConfig,
-    MarkdownSpacingMode, NamedProviderAuth, NamedProviderConfig, NamedProviderModelConfig,
-    NamedProviderType, NativeScrollbarConfig, NotificationsConfig, OverscrollStatusMode,
-    PowerConfig, ProviderConfig, ReasoningDisplayMode, SafetyConfig, SessionPickerResumeAction,
-    SponsorsConfig, SwarmSpawnMode, SwarmStripLayout, TerminalConfig, UpdateChannel,
-    WebSearchConfig, WebSearchEngine,
+    CompactionMode, ContextCompressionConfig, ContextCompressionMode, CrossProviderFailoverMode,
+    DiagramDisplayMode, DiagramPanePosition, DiffDisplayMode, DisplayConfig, FeatureConfig,
+    GatewayConfig, HookCommands, HooksConfig, KeybindingsConfig, LatexRenderingMode,
+    LaunchHotkeyEntry, LaunchHotkeysConfig, MarkdownSpacingMode, NamedProviderAuth,
+    NamedProviderConfig, NamedProviderModelConfig, NamedProviderType, NativeScrollbarConfig,
+    NotificationsConfig, OverscrollStatusMode, PowerConfig, ProviderConfig, ReasoningDisplayMode,
+    SafetyConfig, SessionPickerResumeAction, SponsorsConfig, SwarmSpawnMode, SwarmStripLayout,
+    TerminalConfig, UpdateChannel, WebSearchConfig, WebSearchEngine,
 };
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, BTreeSet, HashSet};
@@ -116,6 +116,10 @@ const CONFIG_ENV_KEYS: &[&str] = &[
     "JCODE_MEMORY_MODEL",
     "JCODE_MEMORY_SIDECAR_ENABLED",
     "JCODE_MEMORY_GRAPHIFY_ENABLED",
+    "JCODE_CONTEXT_COMPRESSION_MODE",
+    "JCODE_CONTEXT_GRAPH_TOKEN_BUDGET",
+    "JCODE_CONTEXT_MAX_GRAPH_ITEMS",
+    "JCODE_CONTEXT_MAX_TOOL_OUTPUT_CHARS",
     "JCODE_MEMORY_VAULT_ENABLED",
     "JCODE_MEMORY_PGVECTOR_ENABLED",
     "JCODE_MEMORY_VAULT_ROOT",
@@ -525,6 +529,9 @@ pub struct Config {
     /// Compaction configuration
     pub compaction: CompactionConfig,
 
+    /// Graph-aware request context compilation.
+    pub context_compression: ContextCompressionConfig,
+
     /// Power-management configuration (prevent sleep while streaming)
     pub power: PowerConfig,
 

crates/jcode-base/src/config/default_file.rs

@@ -470,6 +470,22 @@ memory_vault_enabled = false
 # Pgvector RAG search via /sharedssd/scripts/search_memory.py:
 memory_pgvector_enabled = false
 
+[context_compression]
+# Graph-aware context compilation. "off" preserves the current strategy and is
+# the reproducible baseline. "graph_compact" queries Graphify and injects a
+# bounded, revision-addressed JSON context package. Env:
+# JCODE_CONTEXT_COMPRESSION_MODE
+mode = "off"
+# Maximum estimated Graphify tokens injected per compiled package.
+# Env: JCODE_CONTEXT_GRAPH_TOKEN_BUDGET
+graph_token_budget = 1200
+# Maximum graph nodes emitted per package. Env: JCODE_CONTEXT_MAX_GRAPH_ITEMS
+max_graph_items = 24
+# Tool output characters retained in prompt history in graph-compact mode. Full
+# oversized output is stored under JCODE_HOME/context-store and referenced from
+# the compact result. Env: JCODE_CONTEXT_MAX_TOOL_OUTPUT_CHARS
+max_tool_output_chars = 65536
+
 [terminal]
 # Without a hook, clients inside tmux automatically use a right-side pane.
 # Set JCODE_TERMINAL to force a supported terminal emulator instead.

crates/jcode-base/src/config/display_summary.rs

@@ -100,6 +100,7 @@ impl Config {
 - Memory: {}
 - Memory sidecar: {}
 - Memory enrichment: graphify={}, vault={}, pgvector={}
+- Context compression: {} (graph budget={} tokens, max items={}, tool chars={})
 - Ambient: {}
 
 **Gateway:**
@@ -293,6 +294,10 @@ impl Config {
             self.agents.memory_graphify_enabled,
             self.agents.memory_vault_enabled,
             self.agents.memory_pgvector_enabled,
+            self.context_compression.mode.as_str(),
+            self.context_compression.graph_token_budget,
+            self.context_compression.max_graph_items,
+            self.context_compression.max_tool_output_chars,
             self.ambient
                 .model
                 .as_deref()

crates/jcode-base/src/config/env_overrides.rs

@@ -414,6 +414,26 @@ impl Config {
                 self.agents.memory_graphify_enabled = parsed;
             }
         }
+        if let Ok(v) = std::env::var("JCODE_CONTEXT_COMPRESSION_MODE") {
+            if let Some(parsed) = ContextCompressionMode::parse(&v) {
+                self.context_compression.mode = parsed;
+            }
+        }
+        if let Ok(v) = std::env::var("JCODE_CONTEXT_GRAPH_TOKEN_BUDGET") {
+            if let Ok(parsed) = v.trim().parse::<usize>() {
+                self.context_compression.graph_token_budget = parsed.max(1);
+            }
+        }
+        if let Ok(v) = std::env::var("JCODE_CONTEXT_MAX_GRAPH_ITEMS") {
+            if let Ok(parsed) = v.trim().parse::<usize>() {
+                self.context_compression.max_graph_items = parsed.max(1);
+            }
+        }
+        if let Ok(v) = std::env::var("JCODE_CONTEXT_MAX_TOOL_OUTPUT_CHARS") {
+            if let Ok(parsed) = v.trim().parse::<usize>() {
+                self.context_compression.max_tool_output_chars = parsed.max(1);
+            }
+        }
         if let Ok(v) = std::env::var("JCODE_MEMORY_VAULT_ENABLED") {
             if let Some(parsed) = parse_env_bool(&v) {
                 self.agents.memory_vault_enabled = parsed;