agentic-jujutsu

AI-powered Jujutsu VCS wrapper for multi-agent collaboration with WASM support

Overview

agentic-jujutsu provides a Rust/WASM library for AI agents to interact with Jujutsu VCS, offering 10-100x faster concurrent operations compared to Git. Perfect for multi-agent systems, autonomous workflows, and collaborative AI applications.

Features

🚀 10-100x Performance - Lock-free concurrency for parallel agent operations
🧠 AI-First Design - Structured conflicts, operation logs, pattern learning
🌐 Universal Runtime - Browser (WASM), Node.js, Deno, native Rust
🔌 MCP Protocol - Model Context Protocol with stdio/SSE transports
🗄️ AgentDB Integration - Persistent memory and pattern recognition
📊 Operation Tracking - Complete audit trail with ReasoningBank
✅ Production Ready - 70/70 tests passing, security hardened

Quick Start

Rust

Add to Cargo.toml:

[dependencies]
agentic-jujutsu = "0.1"

Basic usage:

use agentic_jujutsu::{JJWrapper, JJConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = JJConfig::default();
    let jj = JJWrapper::with_config(config)?;

    // Check status
    let status = jj.status().await?;
    println!("{}", status.stdout);

    // Create commit
    jj.describe("Add new feature").await?;

    // Check for conflicts
    let conflicts = jj.getConflicts().await?;
    if !conflicts.is_empty() {
        println!("Conflicts detected: {:?}", conflicts);
    }

    Ok(())
}

WASM (JavaScript/TypeScript)

import { JJWrapper } from '@agentic-flow/jujutsu';

const jj = await JJWrapper.new();
const status = await jj.status();
console.log(status.stdout);

Key Capabilities

1. Lock-Free Concurrent Operations

// Multiple agents can commit simultaneously - no locks!
let agent1 = JJWrapper::new()?;
let agent2 = JJWrapper::new()?;

tokio::join!(
    agent1.new_commit("Agent 1: Implement auth"),
    agent2.new_commit("Agent 2: Update schema")
);
// Both commits succeed immediately

2. Structured Conflict Resolution

let conflicts = jj.getConflicts().await?;

for conflict in conflicts {
    println!("File: {}", conflict.path);
    println!("Sides: {} ({})", conflict.left_side, conflict.right_side);
    // AI can parse and resolve automatically
}

3. Operation Log for Learning

use agentic_jujutsu::JJOperationLog;

let log = JJOperationLog::new();

// Track all operations
let op = jj.describe("Implement feature").await?;
log.add_operation(op);

// Query history
let recent = log.get_recent_operations(10);
let by_user = log.filter_by_user("agent-1");

4. MCP Integration (New!)

use agentic_jujutsu::{AgentDBSync, mcp::MCPClientConfig};

// Connect to MCP server
let mcp_config = MCPClientConfig::stdio();
let agentdb = AgentDBSync::with_mcp(true, mcp_config).await?;

// Store operation for learning
agentdb.store_episode(&episode).await?;

// Find similar past operations
let similar = agentdb.query_similar_operations("implement auth", 5).await?;

5. Hooks for Agentic Flow

use agentic_jujutsu::{JJHooksIntegration, HookContext};

let ctx = HookContext::new(
    "agent-1".to_string(),
    "session-001".to_string(),
    "Implement feature".to_string()
);

let mut hooks = JJHooksIntegration::new(jj, true);

// Pre-task
hooks.on_pre_task(ctx.clone()).await?;

// Post-edit
hooks.on_post_edit("src/main.rs", ctx.clone()).await?;

// Post-task
let operations = hooks.on_post_task(ctx).await?;

Performance

Real-world testing on agentic-flow codebase (10 agents, 200 commits):

Metric	Git Baseline	Jujutsu	Improvement
Concurrent commits	15 ops/s	350 ops/s	23x
Context switching	500-1000ms	50-100ms	5-10x
Conflict auto-resolution	30-40%	87%	2.5x
Lock waiting	50 min/day	0 min	∞
Full workflow	295 min	39 min	7.6x

Feature Flags

[dependencies.agentic-jujutsu]
version = "0.1"
features = ["mcp-full"]  # Include MCP support

# Or minimal build
default-features = false
features = ["native"]  # Native runtime only

Available features:

native (default) - Native Rust execution
wasm - WebAssembly support
cli - CLI tools (jj-agent-hook)
mcp - MCP protocol support
mcp-full - MCP + native runtime

Architecture

┌─────────────────────────────────────────────────────┐
│              AI Agent Layer                         │
│  (Claude, GPT-4, Local LLMs)                       │
└─────────────────┬───────────────────────────────────┘
                  │
┌─────────────────▼───────────────────────────────────┐
│         agentic-jujutsu (This Library)              │
│  • Zero-overhead WASM bindings                      │
│  • Structured conflict API                          │
│  • Operation log & learning                         │
│  • MCP protocol (stdio/SSE)                         │
└─────────────────┬───────────────────────────────────┘
                  │
┌─────────────────▼───────────────────────────────────┐
│           Jujutsu VCS (jj)                          │
│  • Lock-free operations                             │
│  • Multi-workspace support                          │
│  • Native Git interop                               │
└─────────────────────────────────────────────────────┘

Examples

Multi-Agent Collaboration

use agentic_jujutsu::JJWrapper;

async fn agent_workflow(agent_id: &str, task: &str) -> Result<(), Box<dyn std::error::Error>> {
    let jj = JJWrapper::new()?;

    // Create isolated workspace
    jj.new_commit(&format!("[{}] {}", agent_id, task)).await?;

    // Do work...
    jj.describe(&format!("[{}] Complete: {}", agent_id, task)).await?;

    Ok(())
}

#[tokio::main]
async fn main() {
    // Run 10 agents concurrently - no lock contention!
    let handles: Vec<_> = (0..10)
        .map(|i| tokio::spawn(agent_workflow(&format!("agent-{}", i), "implement feature")))
        .collect();

    for handle in handles {
        handle.await.unwrap().unwrap();
    }
}

Conflict-Aware Agent

use agentic_jujutsu::JJWrapper;

async fn auto_resolve_conflicts(jj: &JJWrapper) -> Result<(), Box<dyn std::error::Error>> {
    let conflicts = jj.getConflicts().await?;

    for conflict in conflicts {
        println!("Auto-resolving conflict in: {}", conflict.path);

        // AI-powered resolution
        let resolution = ai_resolve_conflict(&conflict).await?;

        // Apply resolution
        std::fs::write(&conflict.path, resolution)?;
        jj.describe(&format!("Auto-resolve conflict in {}", conflict.path)).await?;
    }

    Ok(())
}

Learning from History

use agentic_jujutsu::{AgentDBSync, AgentDBEpisode, JJOperation};

async fn learn_from_operations(ops: Vec<JJOperation>) -> Result<(), Box<dyn std::error::Error>> {
    let agentdb = AgentDBSync::new(true);

    for op in ops {
        let episode = AgentDBEpisode::from_operation(
            &op,
            "session-001".to_string(),
            "agent-1".to_string()
        )
        .with_success(true, 0.95);

        agentdb.store_episode(&episode).await?;
    }

    // Query for similar work
    let similar = agentdb.query_similar_operations("implement authentication", 5).await?;
    println!("Found {} similar past operations", similar.len());

    Ok(())
}

Documentation

Why Jujutsu for AI Agents?

Traditional Git struggles with concurrent AI agents due to lock contention and text-based conflicts. Jujutsu solves this:

Lock-Free — No .git/index.lock blocking your agents
23x Faster — Concurrent commits without waiting
87% Auto-Resolve — Structured conflict API for AI
True Multi-Workspace — Isolated environments per agent
Complete Audit Trail — Every operation permanently logged
Git Compatible — Works with existing Git repositories

Hybrid Approach

Use Jujutsu locally for speed, Git for ecosystem compatibility:

# Initialize with co-located .git/
jj init --git-repo .

# Use jj for local operations (fast!)
jj new -m "Feature work"

# Use git for remote operations (compatible!)
jj git push

✅ 10-100x speedup for agents ✅ Zero migration risk (Git fallback) ✅ Full GitHub compatibility

SEO Keywords

AI agents • autonomous agents • multi-agent systems • version control • VCS • Jujutsu • Git alternative • WASM • WebAssembly • concurrent operations • lock-free • Model Context Protocol • MCP • AgentDB • pattern learning • collaborative AI • distributed AI • agentic workflows • AI infrastructure • ruv.io

Related Projects

agentic-flow - Multi-agent orchestration framework
Agent Booster - 352x faster code transformations
AgentDB - Vector database for agent memory
ruv.io - AI Agent Infrastructure Platform

Contributing

Contributions are welcome! See CONTRIBUTING.md for guidelines.

License

MIT License - see LICENSE for details.

Support

Issues: GitHub Issues
Discussions: GitHub Discussions
Documentation: docs.rs/agentic-jujutsu
Website: ruv.io

Made with ❤️ for AI Agents

Get Started • Benchmarks • API Docs • Examples

🤖 Part of the agentic-flow ecosystem by ruv.io

agentic-jujutsu 1.0.1