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で見る
