@sparkleideas/agentic-flow 2.0.2-alpha-patch.1

package/packages/agentic-jujutsu/typescript/index.d.ts

@@ -0,0 +1,415 @@
+/**
+ * TypeScript definitions for @agentic-flow/jujutsu
+ * WASM-enabled Jujutsu VCS wrapper for AI agent collaboration
+ */
+
+/**
+ * Configuration for JJWrapper
+ */
+export class JJConfig {
+  /**
+   * Create a new configuration with default values
+   */
+  constructor();
+
+  /**
+   * Create default configuration
+   */
+  static default(): JJConfig;
+
+  /**
+   * Set the path to the jj executable
+   * @param path - Path to jj binary (default: "jj")
+   */
+  with_jj_path(path: string): JJConfig;
+
+  /**
+   * Set the repository path
+   * @param path - Path to repository (default: ".")
+   */
+  with_repo_path(path: string): JJConfig;
+
+  /**
+   * Set operation timeout in milliseconds
+   * @param timeout_ms - Timeout in milliseconds (default: 30000)
+   */
+  with_timeout(timeout_ms: number): JJConfig;
+
+  /**
+   * Enable verbose logging
+   * @param verbose - Enable verbose mode
+   */
+  with_verbose(verbose: boolean): JJConfig;
+
+  /**
+   * Set maximum operation log entries to keep in memory
+   * @param max - Maximum entries (default: 1000)
+   */
+  with_max_log_entries(max: number): JJConfig;
+
+  /**
+   * Enable AgentDB synchronization
+   * @param enable - Enable AgentDB sync
+   */
+  with_agentdb_sync(enable: boolean): JJConfig;
+
+  /** Path to jj executable */
+  jj_path: string;
+
+  /** Repository path */
+  repo_path: string;
+
+  /** Operation timeout in milliseconds */
+  timeout_ms: number;
+
+  /** Enable verbose logging */
+  verbose: boolean;
+
+  /** Maximum operation log entries */
+  max_log_entries: number;
+
+  /** Enable AgentDB sync */
+  enable_agentdb_sync: boolean;
+}
+
+/**
+ * Error types for Jujutsu operations
+ */
+export class JJError extends Error {
+  /**
+   * Get error message as string
+   */
+  message(): string;
+
+  /**
+   * Check if error is recoverable
+   */
+  is_recoverable(): boolean;
+}
+
+/**
+ * Main wrapper for Jujutsu VCS operations
+ */
+export class JJWrapper {
+  /**
+   * Create a new JJWrapper instance
+   * @param config - Optional configuration (uses defaults if not provided)
+   */
+  static new(config?: JJConfig): Promise<JJWrapper>;
+
+  /**
+   * Execute arbitrary jj command
+   * @param args - Command arguments (e.g., ["status"], ["log", "-r", "@"])
+   */
+  execute(args: string[]): Promise<JJResult>;
+
+  /**
+   * Get operation log entries
+   * @param limit - Maximum number of operations to retrieve
+   */
+  getOperations(limit: number): Promise<JJOperation[]>;
+
+  /**
+   * Get conflicts in a commit
+   * @param commit - Optional commit ID (default: working copy)
+   */
+  getConflicts(commit?: string): Promise<JJConflict[]>;
+
+  /**
+   * Set commit description
+   * @param message - Commit message
+   */
+  describe(message: string): Promise<JJOperation>;
+
+  /**
+   * Get repository status
+   */
+  status(): Promise<JJResult>;
+
+  /**
+   * Get diff between two commits
+   * @param from - Source commit
+   * @param to - Target commit
+   */
+  diff(from: string, to: string): Promise<JJDiff>;
+
+  /**
+   * Create a new commit with description
+   * @param message - Commit message
+   */
+  commit(message: string): Promise<JJOperation>;
+
+  /**
+   * Create a new branch
+   * @param name - Branch name
+   */
+  branch_create(name: string): Promise<JJResult>;
+
+  /**
+   * List all branches
+   */
+  branch_list(): Promise<JJBranch[]>;
+
+  /**
+   * Abandon a commit
+   * @param commit - Commit ID to abandon
+   */
+  abandon(commit: string): Promise<JJOperation>;
+
+  /**
+   * Restore files from a commit
+   * @param paths - File paths to restore
+   * @param from - Source commit (default: parent)
+   */
+  restore(paths: string[], from?: string): Promise<JJResult>;
+}
+
+/**
+ * Result of a jj command execution
+ */
+export interface JJResult {
+  /** Exit code of the command */
+  exit_code: number;
+
+  /** Standard output */
+  stdout: string;
+
+  /** Standard error */
+  stderr: string;
+
+  /** Whether the command succeeded */
+  success: boolean;
+}
+
+/**
+ * Jujutsu operation log entry
+ */
+export interface JJOperation {
+  /** Operation ID (hash) */
+  id: string;
+
+  /** Parent operation IDs */
+  parents: string[];
+
+  /** Operation timestamp (ISO 8601) */
+  timestamp: string;
+
+  /** User who performed the operation */
+  user: string;
+
+  /** Operation description */
+  description: string;
+
+  /** Operation type */
+  operation_type: OperationType;
+
+  /** Tags associated with this operation */
+  tags: string[];
+
+  /** Metadata key-value pairs */
+  metadata: Record<string, string>;
+}
+
+/**
+ * Type of Jujutsu operation
+ */
+export type OperationType =
+  | "snapshot"
+  | "describe"
+  | "commit"
+  | "abandon"
+  | "edit"
+  | "new"
+  | "squash"
+  | "unsquash"
+  | "move"
+  | "rebase"
+  | "resolve"
+  | "restore"
+  | "duplicate"
+  | "split"
+  | "unknown";
+
+/**
+ * Conflict in a commit
+ */
+export interface JJConflict {
+  /** File path with conflict */
+  path: string;
+
+  /** Number of conflict hunks */
+  num_hunks: number;
+
+  /** Sides involved in the conflict */
+  sides: ConflictSide[];
+
+  /** Whether the conflict is resolved */
+  resolved: boolean;
+}
+
+/**
+ * Side of a conflict (base, left, right, etc.)
+ */
+export interface ConflictSide {
+  /** Content of this side */
+  content: string;
+
+  /** Label for this side (e.g., "base", "ours", "theirs") */
+  label: string;
+}
+
+/**
+ * Commit information
+ */
+export interface JJCommit {
+  /** Commit ID (change ID) */
+  change_id: string;
+
+  /** Commit hash */
+  commit_id: string;
+
+  /** Parent commit IDs */
+  parents: string[];
+
+  /** Commit description (message) */
+  description: string;
+
+  /** Author name */
+  author: string;
+
+  /** Author email */
+  author_email: string;
+
+  /** Commit timestamp (ISO 8601) */
+  timestamp: string;
+
+  /** Whether this is the working copy */
+  is_working_copy: boolean;
+
+  /** Branches pointing to this commit */
+  branches: string[];
+
+  /** Tags on this commit */
+  tags: string[];
+
+  /** Conflict status */
+  has_conflict: boolean;
+
+  /** Whether this commit is empty */
+  is_empty: boolean;
+}
+
+/**
+ * Branch information
+ */
+export interface JJBranch {
+  /** Branch name */
+  name: string;
+
+  /** Target commit ID */
+  target: string;
+
+  /** Whether this is a remote branch */
+  remote: boolean;
+
+  /** Remote name (if remote branch) */
+  remote_name?: string;
+
+  /** Whether branch is tracking a remote */
+  tracking?: string;
+}
+
+/**
+ * Diff between two commits
+ */
+export interface JJDiff {
+  /** Source commit */
+  from: string;
+
+  /** Target commit */
+  to: string;
+
+  /** File changes */
+  files: FileDiff[];
+
+  /** Summary statistics */
+  stats: DiffStats;
+}
+
+/**
+ * Diff for a single file
+ */
+export interface FileDiff {
+  /** File path */
+  path: string;
+
+  /** Change type */
+  change_type: "added" | "modified" | "deleted" | "renamed" | "copied";
+
+  /** Old path (for renames) */
+  old_path?: string;
+
+  /** Lines added */
+  additions: number;
+
+  /** Lines removed */
+  deletions: number;
+
+  /** Diff hunks */
+  hunks: DiffHunk[];
+}
+
+/**
+ * A hunk in a diff
+ */
+export interface DiffHunk {
+  /** Old file line number */
+  old_start: number;
+
+  /** Old file line count */
+  old_count: number;
+
+  /** New file line number */
+  new_start: number;
+
+  /** New file line count */
+  new_count: number;
+
+  /** Lines in this hunk */
+  lines: DiffLine[];
+}
+
+/**
+ * A line in a diff
+ */
+export interface DiffLine {
+  /** Line type: " " (context), "+" (added), "-" (removed) */
+  type: " " | "+" | "-";
+
+  /** Line content */
+  content: string;
+}
+
+/**
+ * Diff statistics
+ */
+export interface DiffStats {
+  /** Total files changed */
+  files_changed: number;
+
+  /** Total insertions */
+  insertions: number;
+
+  /** Total deletions */
+  deletions: number;
+}
+
+/**
+ * Initialize WASM module (for web target)
+ */
+export function init(): void;
+
+/**
+ * Version of the agentic-jujutsu package
+ */
+export const VERSION: string;

package/reasoningbank/README.md

@@ -0,0 +1,217 @@
+# 🧠 ReasoningBank
+
+[![Crates.io](https://img.shields.io/crates/v/reasoningbank?style=flat-square)](https://crates.io/crates/reasoningbank)
+[![Documentation](https://img.shields.io/docsrs/reasoningbank?style=flat-square)](https://docs.rs/reasoningbank)
+[![License](https://img.shields.io/crates/l/reasoningbank?style=flat-square)](LICENSE)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/ruvnet/agentic-flow/ci.yml?style=flat-square)](https://github.com/ruvnet/agentic-flow/actions)
+[![Rust Version](https://img.shields.io/badge/rust-1.70%2B-blue?style=flat-square)](https://www.rust-lang.org)
+
+> **Adaptive self-learning reasoning system with embedded storage and QUIC neural bus**
+
+ReasoningBank is a high-performance, self-learning AI reasoning system that learns from experience and improves over time. It combines pattern recognition, adaptive strategy optimization, and distributed neural communication to build smarter AI agents.
+
+---
+
+## 🎯 What is ReasoningBank?
+
+**For Non-Technical Users:**
+
+Think of ReasoningBank as a "memory and learning system" for AI. Just like humans learn from experience and get better at tasks over time, ReasoningBank helps AI systems:
+
+- **Remember** what worked and what didn't in past tasks
+- **Learn** from successful strategies and avoid repeating mistakes
+- **Adapt** by automatically choosing the best approach for new challenges
+- **Share** knowledge efficiently across distributed AI agents
+
+It's like giving your AI a notebook, a teacher, and a communication system all in one.
+
+**For Technical Users:**
+
+ReasoningBank is a Rust-based adaptive learning framework that provides:
+
+- **Pattern Storage**: Embedded SQLite with WAL mode, connection pooling, and optimized queries
+- **Adaptive Learning**: Cosine similarity-based pattern matching, strategy scoring, and confidence-weighted recommendations
+- **Neural Bus**: QUIC-based communication protocol with Ed25519-signed intent-capped actions, stream multiplexing, and gossip protocols
+- **Async-First Design**: Actor pattern for thread-safe async operations with message-passing architecture
+- **MCP Integration**: Full Model Context Protocol server with tools and resources for AI agent coordination
+
+---
+
+## ✨ Features
+
+### 🎓 Core Learning Capabilities
+
+- **Pattern Recognition**: Stores and retrieves task patterns with vector embeddings
+- **Similarity Matching**: Cosine and Euclidean distance algorithms for finding relevant experiences
+- **Strategy Optimization**: Automatically identifies and recommends successful strategies
+- **Success Tracking**: Confidence-weighted success rates and outcome analysis
+- **Adaptive Recommendations**: Context-aware strategy suggestions based on task characteristics
+
+### 💾 High-Performance Storage
+
+- **Embedded SQLite**: Zero-configuration, file-based or in-memory storage
+- **Connection Pooling**: Efficient multi-threaded access with Parking Lot synchronization
+- **Write-Ahead Logging (WAL)**: Concurrent reads during writes for maximum throughput
+- **Optimized Queries**: Indexed searches, prepared statements, and efficient similarity calculations
+- **Migration System**: Automatic schema versioning and upgrades
+
+### 🚀 QUIC Neural Bus
+
+- **0-RTT Connections**: Sub-millisecond connection establishment
+- **Stream Multiplexing**: Parallel data streams without head-of-line blocking
+- **Intent-Capped Actions**: Ed25519-signed authorization with spend caps and scope restrictions
+- **Reasoning Streams**: Separate channels for tokens, traces, rubrics, and verification
+- **Gossip Protocol**: Decentralized knowledge sharing across agent networks
+- **Snapshot Streaming**: Efficient large-state transfer with chunking
+
+### 🔧 Developer Experience
+
+- **Async/Await Support**: Full Tokio integration with spawn_blocking for sync operations
+- **Actor Pattern**: Thread-safe message passing eliminates Send/Sync issues
+- **Type-Safe API**: Strongly-typed interfaces with comprehensive error handling
+- **MCP Tools**: Ready-to-use server with pattern storage, retrieval, analysis, and optimization tools
+- **Extensive Tests**: 60+ unit and integration tests with 90%+ coverage
+- **Performance Benchmarks**: Criterion-based benchmarking for storage, learning, and neural bus operations
+
+---
+
+## 📦 Installation
+
+Add ReasoningBank to your `Cargo.toml`:
+
+```toml
+[dependencies]
+reasoningbank-core = "0.1.0"          # Core reasoning engine
+reasoningbank-storage = "0.1.0"       # SQLite storage layer
+reasoningbank-learning = "0.1.0"      # Adaptive learning system
+reasoningbank-network = "0.1.0"       # QUIC neural bus
+reasoningbank-mcp = "0.1.0"          # MCP server integration
+```
+
+### Requirements
+
+- **Rust**: 1.70 or later
+- **OS**: Linux, macOS, Windows (SQLite bundled for all platforms)
+- **Features**: `tokio` async runtime, `rusqlite` with bundled SQLite
+
+---
+
+## 🚀 Quick Start
+
+### Basic Pattern Storage and Learning
+
+```rust
+use reasoningbank_core::{Pattern, TaskOutcome, ReasoningEngine, EngineConfig};
+use reasoningbank_learning::{AdaptiveLearner, LearningConfig};
+use reasoningbank_storage::{SqliteStorage, StorageConfig};
+use std::path::PathBuf;
+
+fn main() -> anyhow::Result<()> {
+    // Initialize storage
+    let storage_config = StorageConfig {
+        database_path: PathBuf::from("reasoningbank.db"),
+        max_connections: 10,
+        enable_wal: true,
+        cache_size_kb: 8192,
+    };
+    let storage = SqliteStorage::new(storage_config)?;
+
+    // Create reasoning engine and learner
+    let engine = ReasoningEngine::new(EngineConfig::default());
+    let mut learner = AdaptiveLearner::new(
+        engine,
+        storage,
+        LearningConfig::default(),
+    );
+
+    // Store a successful task pattern
+    let pattern = Pattern::new(
+        "Implement REST API endpoint".to_string(),
+        "backend_development".to_string(),
+        "test_driven_development".to_string(),
+    ).with_outcome(TaskOutcome::success(0.95));
+
+    let insight = learner.learn_from_task(&pattern)?;
+    println!("Learning insight: {:?}", insight);
+
+    // Get recommendations for a new task
+    let applied = learner.apply_learning(
+        "Build a new API endpoint",
+        "backend_development",
+    )?;
+
+    println!("Recommended strategy: {}", applied.recommended_strategy);
+    println!("Confidence: {:.2}%", applied.confidence * 100.0);
+
+    Ok(())
+}
+```
+
+---
+
+## 📚 Documentation
+
+### Architecture Overview
+
+ReasoningBank uses a modular architecture with six primary crates:
+
+- **reasoningbank-core**: Core reasoning engine with pattern matching
+- **reasoningbank-storage**: SQLite storage layer with connection pooling
+- **reasoningbank-learning**: Adaptive learning system with similarity matching
+- **reasoningbank-network**: QUIC neural bus with intent verification
+- **reasoningbank-mcp**: MCP server with tools and resources
+- **reasoningbank-wasm**: WASM bindings (placeholder for future web support)
+
+### Performance
+
+Based on Criterion benchmarks:
+
+- **Storage**: ~200-300 µs per pattern storage, ~50-100 µs per lookup
+- **Learning**: ~2.6 ms per learning operation, ~4.7 ms per recommendation
+- **Neural Bus**: ~5-10 µs per frame encode/decode (1KB payload)
+
+---
+
+## 🧪 Testing
+
+```bash
+# Run all tests
+cargo test --all-features
+
+# Run benchmarks
+cargo bench
+
+# Generate benchmark HTML reports
+cargo bench -- --save-baseline baseline-v1
+```
+
+**Test Coverage**: 60+ tests across all crates with 90%+ coverage
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome! Please:
+
+- Write tests for new features
+- Run `cargo fmt` and `cargo clippy` before committing
+- Update documentation for API changes
+- Add benchmarks for performance-critical code
+
+---
+
+## 📄 License
+
+Dual-licensed under MIT or Apache-2.0 at your option.
+
+---
+
+## 🙏 Acknowledgments
+
+Built with [Rust](https://www.rust-lang.org/), [SQLite](https://www.sqlite.org/), [Quinn](https://github.com/quinn-rs/quinn), [Tokio](https://tokio.rs/), and [Criterion](https://github.com/bheisler/criterion.rs).
+
+---
+
+<p align="center">
+  <sub>Built with ❤️ by the ReasoningBank contributors</sub>
+</p>