agentic-jujutsu
Quantum-resistant, self-learning version control for AI agents with ReasoningBank intelligence and multi-agent coordination
소스 정보
- 저장소
- ruvnet/ruflo
- 최근 소스 활동
- 2026년 3월 25일 20:28
- 감지된 SKILL.md 언어
- 영어
- 스타
- 73,469
- 포크
- 8,725
설치 방법
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
소스 파일 검토
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
SKILL.md 표시 중
SKILL.md
소스 지침 · 읽기 전용 미리보기- name
- agentic-jujutsu
- description
- Quantum-resistant, self-learning version control for AI agents with ReasoningBank intelligence and multi-agent coordination
# Agentic Jujutsu - AI Agent Version Control
> Quantum-ready, self-learning version control designed for multiple AI agents working simultaneously without conflicts.
## When to Use This Skill
Use **agentic-jujutsu** when you need:
- ✅ Multiple AI agents modifying code simultaneously
- ✅ Lock-free version control (23x faster than Git)
- ✅ Self-learning AI that improves from experience
- ✅ Quantum-resistant security for future-proof protection
- ✅ Automatic conflict resolution (87% success rate)
- ✅ Pattern recognition and intelligent suggestions
- ✅ Multi-agent coordination without blocking
## Quick Start
### Installation
```bash
npx agentic-jujutsu
```
### Basic Usage
```javascript
const { JjWrapper } = require('agentic-jujutsu');
const jj = new JjWrapper();
// Basic operations
await jj.status();
await jj.newCommit('Add feature');
await jj.log(10);
// Self-learning trajectory
const id = jj.startTrajectory('Implement authentication');
await jj.branchCreate('feature/auth');
await jj.newCommit('Add auth');
jj.addToTrajectory();
jj.finalizeTrajectory(0.9, 'Clean implementation');
// Get AI suggestions
const suggestion = JSON.parse(jj.getSuggestion('Add logout feature'));
console.log(`Confidence: ${suggestion.confidence}`);
```
## Core Capabilities
### 1. Self-Learning with ReasoningBank
Track operations, learn patterns, and get intelligent suggestions:
```javascript
// Start learning trajectory
const trajectoryId = jj.startTrajectory('Deploy to production');
// Perform operations (automatically tracked)
await jj.execute(['git', 'push', 'origin', 'main']);
await jj.branchCreate('release/v1.0');
await jj.newCommit('Release v1.0');
// Record operations to trajectory
jj.addToTrajectory();
// Finalize with success score (0.0-1.0) and critique
jj.finalizeTrajectory(0.95, 'Deployment successful, no issues');
// Later: Get AI-powered suggestions for similar tasks
const suggestion = JSON.parse(jj.getSuggestion('Deploy to staging'));
console.log('AI Recommendation:', suggestion.reasoning);
console.log('Confidence:', (suggestion.confidence * 100).toFixed(1) + '%');
console.log('Expected Success:', (suggestion.expectedSuccessRate * 100).toFixed(1) + '%');
```
**Validation (v2.3.1)**:
- ✅ Tasks must be non-empty (max 10KB)
- ✅ Success scores must be 0.0-1.0
- ✅ Must have operations before finalizing
- ✅ Contexts cannot be empty
### 2. Pattern Discovery
Automatically identify successful operation sequences:
```javascript
// Get discovered patterns
const patterns = JSON.parse(jj.getPatterns());
patterns.forEach(pattern => {
console.log(`Pattern: ${pattern.name}`);
console.log(` Success rate: ${(pattern.successRate * 100).toFixed(1)}%`);
console.log(` Used ${pattern.observationCount} times`);
console.log(` Operations: ${pattern.operationSequence.join(' → ')}`);
console.log(` Confidence: ${(pattern.confidence * 100).toFixed(1)}%`);
});
```
### 3. Learning Statistics
Track improvement over time:
```javascript
const stats = JSON.parse(jj.getLearningStats());
console.log('Learning Progress:');
console.log(` Total trajectories: ${stats.totalTrajectories}`);
console.log(` Patterns discovered: ${stats.totalPatterns}`);
console.log(` Average success: ${(stats.avgSuccessRate * 100).toFixed(1)}%`);
console.log(` Improvement rate: ${(stats.improvementRate * 100).toFixed(1)}%`);
console.log(` Prediction accuracy: ${(stats.predictionAccuracy * 100).toFixed(1)}%`);
```
### 4. Multi-Agent Coordination
Multiple agents work concurrently without conflicts:
```javascript
// Agent 1: Developer
const dev = new JjWrapper();
dev.startTrajectory('Implement feature');
await dev.newCommit('Add feature X');
dev.addToTrajectory();
dev.finalizeTrajectory(0.85);
// Agent 2: Reviewer (learns from Agent 1)
const reviewer = new JjWrapper();
const suggestion = JSON.parse(reviewer.getSuggestion('Review feature X'));
if (suggestion.confidence > 0.7) {
console.log('High confidence approach:', suggestion.reasoning);
}
// Agent 3: Tester (benefits from both)
const tester = new JjWrapper();
const similar = JSON.parse(tester.queryTrajectories('test feature', 5));
console.log(`Found ${similar.length} similar test approaches`);
```
### 5. Quantum-Resistant Security (v2.3.0+)
Fast integrity verification with quantum-resistant cryptography:
```javascript
const { generateQuantumFingerprint, verifyQuantumFingerprint } = require('agentic-jujutsu');
// Generate SHA3-512 fingerprint (NIST FIPS 202)
const data = Buffer.from('commit-data');
const fingerprint = generateQuantumFingerprint(data);
console.log('Fingerprint:', fingerprint.toString('hex'));
// Verify integrity (<1ms)
const isValid = verifyQuantumFingerprint(data, fingerprint);
console.log('Valid:', isValid);
// HQC-128 encryption for trajectories
const crypto = require('crypto');
const key = crypto.randomBytes(32).toString('base64');
jj.enableEncryption(key);
```
### 6. Operation Tracking with AgentDB
Automatic tracking of all operations:
```javascript
// Operations are tracked automatically
await jj.status();
await jj.newCommit('Fix bug');
await jj.rebase('main');
// Get operation statistics
const stats = JSON.parse(jj.getStats());
console.log(`Total operations: ${stats.total_operations}`);
console.log(`Success rate: ${(stats.success_rate * 100).toFixed(1)}%`);
console.log(`Avg duration: ${stats.avg_duration_ms.toFixed(2)}ms`);
// Query recent operations
const ops = jj.getOperations(10);
ops.forEach(op => {
console.log(`${op.operationType}: ${op.command}`);
console.log(` Duration: ${op.durationMs}ms, Success: ${op.success}`);
});
// Get user operations (excludes snapshots)
const userOps = jj.getUserOperations(20);
```
## Advanced Use Cases
### Use Case 1: Adaptive Workflow Optimization
Learn and improve deployment workflows:
```javascript
async function adaptiveDeployment(jj, environment) {
// Get AI suggestion based on past deployments
const suggestion = JSON.parse(jj.getSuggestion(`Deploy to ${environment}`));
console.log(`Deploying with ${(suggestion.confidence * 100).toFixed(0)}% confidence`);
console.log(`Expected duration: ${suggestion.estimatedDurationMs}ms`);
// Start tracking
jj.startTrajectory(`Deploy to ${environment}`);
// Execute recommended operations
for (const op of suggestion.recommendedOperations) {
console.log(`Executing: ${op}`);
await executeOperation(op);
}
jj.addToTrajectory();
// Record outcome
const success = await verifyDeployment();
jj.finalizeTrajectory(
success ? 0.95 : 0.5,
success ? 'Deployment successful' : 'Issues detected'
);
}
```
### Use Case 2: Multi-Agent Code Review
Coordinate review across multiple agents:
```javascript
async function coordinatedReview(agents) {
const reviews = await Promise.all(agents.map(async (agent) => {
const jj = new JjWrapper();
// Start review trajectory
jj.startTrajectory(`Review by ${agent.name}`);
// Get AI suggestion for review approach
const suggestion = JSON.parse(jj.getSuggestion('Code review'));
// Perform review
const diff = await jj.diff('@', '@-');
const issues = await agent.analyze(diff);
jj.addToTrajectory();
jj.finalizeTrajectory(
issues.length === 0 ? 0.9 : 0.6,
`Found ${issues.length} issues`
);
return { agent: agent.name, issues, suggestion };
}));
// Aggregate learning from all agents
return reviews;
}
```
### Use Case 3: Error Pattern Detection
Learn from failures to prevent future issues:
```javascript
async function smartMerge(jj, branch) {
// Query similar merge attempts
const similar = JSON.parse(jj.queryTrajectories(`merge ${branch}`, 10));
// Analyze past failures
const failures = similar.filter(t => t.successScore < 0.5);
if (failures.length > 0) {
console.log('⚠️ Similar merges failed in the past:');
failures.forEach(f => {
if (f.critique) {
console.log(` - ${f.critique}`);
}
});
}
// Get AI recommendation
const suggestion = JSON.parse(jj.getSuggestion(`merge ${branch}`));
if (suggestion.confidence < 0.7) {
console.log('⚠️ Low confidence. Recommended steps:');
suggestion.recommendedOperations.forEach(op => console.log(` - ${op}`));
}
// Execute merge with tracking
jj.startTrajectory(`Merge ${branch}`);
try {
await jj.execute(['merge', branch]);
jj.addToTrajectory();
jj.finalizeTrajectory(0.9, 'Merge successful');
} catch (err) {
jj.addToTrajectory();
jj.finalizeTrajectory(0.3, `Merge failed: ${err.message}`);
throw err;
}
}
```
### Use Case 4: Continuous Learning Loop
Implement a self-improving agent:
```javascript
class SelfImprovingAgent {
constructor() {
this.jj = new JjWrapper();
}
async performTask(taskDescription) {
// Get AI suggestion
const suggestion = JSON.parse(this.jj.getSuggestion(taskDescription));
console.log(`Task: ${taskDescription}`);
console.log(`AI Confidence: ${(suggestion.confidence * 100).toFixed(1)}%`);
console.log(`Expected Success: ${(suggestion.expectedSuccessRate * 100).toFixed(1)}%`);
// Start trajectory
this.jj.startTrajectory(taskDescription);
// Execute with recommended approach
const startTime = Date.now();
let success = false;
try {
for (const op of suggestion.recommendedOperations) {
await this.execute(op);
}
success = true;
} catch (err) {
console.error('Task failed:', err.message);
}
const duration = Date.now() - startTime;
// Record learning
this.jj.addToTrajectory();
this.jj.finalizeTrajectory(
success ? 0.9 : 0.4,
success
? `Completed in ${duration}ms using ${suggestion.recommendedOperations.length} operations`
: `Failed after ${duration}ms`
);
// Check improvement
const stats = JSON.parse(this.jj.getLearningStats());
console.log(`Improvement rate: ${(stats.improvementRate * 100).toFixed(1)}%`);
return success;
}
async execute(operation) {
// Execute operation logic
}
}
// Usage
const agent = new SelfImprovingAgent();
// Agent improves over time
for (let i = 1; i <= 10; i++) {
console.log(`\n--- Attempt ${i} ---`);
await agent.performTask('Deploy application');
}
```
## API Reference
### Core Methods
| Method | Description | Returns |
|--------|-------------|---------|
| `new JjWrapper()` | Create wrapper instance | JjWrapper |
| `status()` | Get repository status | Promise<JjResult> |
| `newCommit(msg)` | Create new commit | Promise<JjResult> |
| `log(limit)` | Show commit history | Promise<JjCommit[]> |
| `diff(from, to)` | Show differences | Promise<JjDiff> |
| `branchCreate(name, rev?)` | Create branch | Promise<JjResult> |
GitHub에서 보기이 SKILL.md는 매우 커서 SkillsMP가 여기에는 첫 섹션만 미리 보여줍니다. GitHub에서 보기
