mcpField
A
agentic-jujutsu

agentic-jujutsu

github.com/proffesor-for-testingエージェントワークフロー51939 回インストール1 日前に更新
リポジトリ

agentic-jujutsu について

agentic-jujutsuは、AIエージェント向けのバージョン管理ツールです。リポジトリ操作をまとめ、記録したタスク履歴からパターンを学習して提案を生成します。複数エージェントの協調や反復作業の改善に使えます。

主な機能

  1. 01状態・コミット・ブランチ操作のラッパー
  2. 02操作と利用統計の記録
  3. 03タスク履歴からのパターン学習
  4. 04過去の履歴に基づく提案
  5. 05複数エージェントの並行作業
  6. 06SHA3-512整合性フィンガープリント

活用シーン

  1. 01複数エージェントによるコード変更
  2. 02デプロイ履歴を基にしたワークフロー改善
  3. 03類似タスクの検索と失敗分析

インストール

コマンドをコピーしてターミナルで実行します。

$npx skills add https://github.com/proffesor-for-testing/agentic-qe --skill agentic-jujutsu

インストール後、Claude Code で/agentic-jujutsuを入力して読み込まれたか確認します。

詳細

エージェント型 Jujutsu - AI エージェント向けバージョン管理

複数の AI エージェントが同時に競合なく作業できるように設計された、量子耐性を備えた自己学習型バージョン管理システムです。

このスキルを使用する場面

次のような場合は、agentic-jujutsu を使用してください。

  • ✅ 複数の AI エージェントが同時にコードを変更する場合
  • ✅ ロックフリーのバージョン管理が必要な場合（Git より 23 倍高速）
  • ✅ 経験から改善する自己学習型 AI が必要な場合
  • ✅ 将来に備えた保護のため、量子耐性セキュリティが必要な場合
  • ✅ 自動競合解決が必要な場合（成功率 87％）
  • ✅ パターン認識とインテリジェントな提案が必要な場合
  • ✅ ブロックせずに複数エージェントを連携させる場合

クイックスタート

インストール
npx agentic-jujutsu
基本的な使い方
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}`);

主な機能

1. ReasoningBank による自己学習

操作を追跡してパターンを学習し、インテリジェントな提案を取得します。

// 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) + '%');

検証（v2.3.1）:

  • ✅ タスクは空でないこと（最大 10KB）
  • ✅ 成功スコアは 0.0～1.0 であること
  • ✅ 完了前に操作が記録されていること
  • ✅ コンテキストが空でないこと
2. パターンの検出

成功した操作シーケンスを自動的に特定します。

// 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. 学習統計

時間の経過に伴う改善状況を追跡します。

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. マルチエージェント連携

複数のエージェントが競合なく同時に作業します。

// 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. 量子耐性セキュリティ（v2.3.0 以降）

量子耐性暗号を用いて整合性を高速に検証します。

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. AgentDB による操作の追跡

すべての操作を自動的に追跡します。

// 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);

高度な使用例

使用例 1：適応型ワークフローの最適化

デプロイのワークフローを学習して改善します。

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'
    );
}
使用例 2：マルチエージェントによるコードレビュー

複数のエージェント間でレビューを調整します。

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;
}
使用例 3：エラーパターンの検出

失敗から学習して、今後の問題を防ぎます。

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;
    }
}
使用例 4：継続的な学習ループ

自己改善型エージェントを実装します。

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 リファレンス

主なメソッド
メソッド説明戻り値
new JjWrapper()ラッパーインスタンスを作成JjWrapper
status()リポジトリの状態を取得Promise
newCommit(msg)新しいコミットを作成Promise
log(limit)コミット履歴を表示Promise<JjCommit[]>
diff(from, to)差分を表示Promise
branchCreate(name, rev?)ブランチを作成Promise
rebase(source, dest)コミットをリベースPromise
ReasoningBank のメソッド
メソッド説明戻り値
startTrajectory(task)学習トラジェクトリを開始string (trajectory ID)
addToTrajectory()直近の操作を追加void
finalizeTrajectory(score, critique?)トラジェクトリを完了（スコア：0.0～1.0）void
getSuggestion(task)AI の推奨事項を取得JSON: DecisionSuggestion
getLearningStats()学習指標を取得JSON: LearningStats
getPatterns()検出されたパターンを取得JSON: Pattern[]
queryTrajectories(task, limit)類似するトラジェクトリを検索JSON: Trajectory[]
resetLearning()学習データを消去void
AgentDB のメソッド
メソッド説明戻り値
getStats()操作統計を取得JSON: Stats
getOperations(limit)最近の操作を取得JjOperation[]
getUserOperations(limit)ユーザーの操作のみを取得JjOperation[]
clearLog()操作ログを消去void
量子セキュリティのメソッド（v2.3.0 以降）
メソッド説明戻り値
generateQuantumFingerprint(data)SHA3-512 フィンガープリントを生成Buffer (64 bytes)
verifyQuantumFingerprint(data, fp)フィンガープリントを検証boolean
enableEncryption(key, pubKey?)HQC-128 暗号化を有効化void
disableEncryption()暗号化を無効化void
isEncryptionEnabled()暗号化の状態を確認boolean

パフォーマンス特性

指標GitAgentic Jujutsu
同時コミット数15 ops/s350 ops/s（23倍）
コンテキスト切り替え500-1000ms50-100ms（10倍）
コンフリクト解決30-40% 自動87% 自動（2.5倍）
ロック待ち時間50 分/日0 分（∞）
量子フィンガープリント該当なし<1ms

ベストプラクティス

1. 軌跡の管理
// ✅ Good: Meaningful task descriptions
jj.startTrajectory('Implement user authentication with JWT');

// ❌ Bad: Vague descriptions
jj.startTrajectory('fix stuff');

// ✅ Good: Honest success scores
jj.finalizeTrajectory(0.7, 'Works but needs refactoring');

// ❌ Bad: Always 1.0
jj.finalizeTrajectory(1.0, 'Perfect!'); // Prevents learning
2. パターン認識
// ✅ Good: Let patterns emerge naturally
for (let i = 0; i < 10; i++) {
    jj.startTrajectory('Deploy feature');
    await deploy();
    jj.addToTrajectory();
    jj.finalizeTrajectory(wasSuccessful ? 0.9 : 0.5);
}

// ❌ Bad: Not recording outcomes
await deploy(); // No learning
3. マルチエージェントの連携
// ✅ Good: Concurrent operations
const agents = ['agent1', 'agent2', 'agent3'];
await Promise.all(agents.map(async (agent) => {
    const jj = new JjWrapper();
    // Each agent works independently
    await jj.newCommit(`Changes by ${agent}`);
}));

// ❌ Bad: Sequential with locks
for (const agent of agents) {
    await agent.waitForLock(); // Not needed!
    await agent.commit();
}
4. エラー処理
// ✅ Good: Record failures with details
try {
    await jj.execute(['complex-operation']);
    jj.finalizeTrajectory(0.9);
} catch (err) {
    jj.finalizeTrajectory(0.3, `Failed: ${err.message}. Root cause: ...`);
}

// ❌ Bad: Silent failures
try {
    await jj.execute(['operation']);
} catch (err) {
    // No learning from failure
}

検証ルール（v2.3.1+）

タスクの説明
  • ✅ 空または空白文字のみにはできません
  • ✅ 最大長：10,000 バイト
  • ✅ 自動的にトリミングされます
成功スコア
  • ✅ 有限値である必要があります（NaN または Infinity ではないこと）
  • ✅ 0.0 以上 1.0 以下（両端を含む）である必要があります
操作
  • ✅ 確定する前に、少なくとも 1 つの操作が必要です
コンテキスト
  • ✅ 空にはできません
  • ✅ キーを空または空白文字のみにはできません
  • ✅ キーは最大 1,000 バイト、値は最大 10,000 バイトです

トラブルシューティング

問題：信頼度の低い提案
const suggestion = JSON.parse(jj.getSuggestion('new task'));

if (suggestion.confidence < 0.5) {
    // Not enough data - check learning stats
    const stats = JSON.parse(jj.getLearningStats());
    console.log(`Need more data. Current trajectories: ${stats.totalTrajectories}`);
    
    // Recommend: Record 5-10 trajectories first
}
問題：検証エラー
try {
    jj.startTrajectory(''); // Empty task
} catch (err) {
    if (err.message.includes('Validation error')) {
        console.log('Invalid input:', err.message);
        // Use non-empty, meaningful task description
    }
}

try {
    jj.finalizeTrajectory(1.5); // Score > 1.0
} catch (err) {
    // Use score between 0.0 and 1.0
    jj.finalizeTrajectory(Math.max(0, Math.min(1, score)));
}
問題：パターンが見つからない
const patterns = JSON.parse(jj.getPatterns());

if (patterns.length === 0) {
    // Need more trajectories with >70% success
    // Record at least 3-5 successful trajectories
}

例

例 1：シンプルな学習ワークフロー
const { JjWrapper } = require('agentic-jujutsu');

async function learnFromWork() {
    const jj = new JjWrapper();
    
    // Start tracking
    jj.startTrajectory('Add user profile feature');
    
    // Do work
    await jj.branchCreate('feature/user-profile');
    await jj.newCommit('Add user profile model');
    await jj.newCommit('Add profile API endpoints');
    await jj.newCommit('Add profile UI');
    
    // Record operations
    jj.addToTrajectory();
    
    // Finalize with result
    jj.finalizeTrajectory(0.85, 'Feature complete, minor styling issues remain');
    
    // Next time, get suggestions
    const suggestion = JSON.parse(jj.getSuggestion('Add settings page'));
    console.log('AI suggests:', suggestion.reasoning);
}
例 2：マルチエージェントスウォーム
async function agentSwarm(taskList) {
    const agents = taskList.map((task, i) => ({
        name: `agent-${i}`,
        jj: new JjWrapper(),
        task
    }));
    
    // All agents work concurrently (no conflicts!)
    const results = await Promise.all(agents.map(async (agent) => {
        agent.jj.startTrajectory(agent.task);
        
        // Get AI suggestion
        const suggestion = JSON.parse(agent.jj.getSuggestion(agent.task));
        
        // Execute task
        const success = await executeTask(agent, suggestion);
        
        agent.jj.addToTrajectory();
        agent.jj.finalizeTrajectory(success ? 0.9 : 0.5);
        
        return { agent: agent.name, success };
    }));
    
    console.log('Results:', results);
}

関連ドキュメント

バージョン履歴

  • v2.3.2 - ドキュメントを更新
  • v2.3.1 - ReasoningBank の検証を修正
  • v2.3.0 - @qudag/napi-core による量子耐性セキュリティ
  • v2.1.0 - ReasoningBank による自己学習型 AI
  • v2.0.0 - jj バイナリを組み込んだ依存関係ゼロのインストール

ステータス：✅ 本番環境対応 ライセンス：MIT メンテナンス状況：継続中

コメント

Markdown 対応