Struct WeaverEngine 

pub struct WeaverEngine { /* private fields */ }

ECC-powered codebase modeling service.

Manages modeling sessions, drives confidence evaluation via the causal graph, and records modeling decisions in the Meta-Loom.

Implementations

impl WeaverEngine

pub fn new( causal_graph: Arc<CausalGraph>, hnsw: Arc<HnswService>, embedding_provider: Arc<dyn EmbeddingProvider>, ) -> Self

Create a new WeaverEngine with the given dependencies.

pub fn new_with_mock( causal_graph: Arc<CausalGraph>, hnsw: Arc<HnswService>, ) -> Self

Create a WeaverEngine with a mock embedding provider (for tests).

pub fn set_impulse_queue(&mut self, queue: Arc<ImpulseQueue>)

Set the impulse queue for emitting meta-loom signals.

pub fn knowledge_base(&self) -> &Arc<WeaverKnowledgeBase>

Get a reference to the knowledge base.

pub fn embedding_provider(&self) -> &Arc<dyn EmbeddingProvider>

Get a reference to the embedding provider.

pub fn causal_graph(&self) -> &Arc<CausalGraph>

Get a reference to the causal graph.

pub fn hnsw(&self) -> &Arc<HnswService>

Get a reference to the HNSW service.

pub fn ingest_graph_file( &self, path: &Path, ) -> Result<IngestResult, WeaverError>

Ingest a graph JSON file (git-history, module-deps, or decisions).

Reads a .weftos/graph/*.json file, creates causal graph nodes for each entry, creates edges between related nodes, and inserts embeddings into the HNSW index for each node’s text representation.

pub fn ingest_graph_file_tracked( &mut self, path: &Path, ) -> Result<IngestResult, WeaverError>

Ingest a graph file with strategy tracking and confidence history.

Wraps [ingest_graph_file] with before/after confidence measurement, recording the result in the StrategyTracker and ConfidenceHistory.

pub fn compute_confidence(&self) -> ConfidenceReport

Compute confidence based on graph coverage.

Examines the causal graph to determine what fraction of nodes have edges (both incoming and outgoing), the edge density, and identifies orphan nodes that lack causal connections.

pub fn export_model_to_file( &self, domain: &str, min_confidence: f64, path: &Path, ) -> Result<ExportedModel, WeaverError>

Export the current model state to a JSON file at the given path.

Produces a weave-model.json that includes the causal graph nodes, edges, confidence report, and metadata.

pub fn import_model_from_file( &self, domain: &str, path: &Path, ) -> Result<(), WeaverError>

Import a model from a JSON file.

pub fn start_session( &self, domain: &str, context: Option<&str>, _goal: Option<&str>, ) -> Result<String, String>

Start a new modeling session.

pub fn stop_session(&self, domain: &str) -> Result<(), String>

Stop a modeling session.

pub fn resume_session(&self, domain: &str) -> Result<(), String>

Resume a stopped session.

pub fn get_session(&self, domain: &str) -> Option<ModelingSession>

Get a snapshot of a session.

pub fn list_sessions(&self) -> Vec<String>

List all session domains.

pub fn add_source( &self, domain: &str, source_type: &str, _root: Option<&PathBuf>, ) -> Result<(), String>

Add a data source to a session.

pub fn evaluate_confidence( &self, domain: &str, ) -> Result<ConfidenceReport, String>

Evaluate confidence for a session domain.

pub fn tick(&self, budget: Duration) -> TickResult

Process a single cognitive tick.

Called by the CognitiveTick service during each tick cycle. Budget-aware: yields if budget is exhausted.

pub fn export_model( &self, domain: &str, min_confidence: f64, ) -> Result<ExportedModel, String>

Export the model for a domain.

pub fn import_model( &self, domain: &str, model: ExportedModel, ) -> Result<(), String>

Import a previously exported model.

pub fn handle_command(&self, cmd: WeaverCommand) -> WeaverResponse

Handle a WeaverCommand received via IPC.

pub fn meta_loom_events(&self, domain: &str) -> Vec<MetaLoomEvent>

Get meta-loom events for a domain.

pub fn on_tick(&mut self, budget_ms: u32) -> CognitiveTickResult

Handle a cognitive tick — process pending work within budget.

Called by the CognitiveTick service each cycle. Performs git polling, file change detection, pending ingestion, and periodic confidence recomputation, all within the supplied time budget.

pub fn enable_git_polling(&mut self, repo_path: PathBuf, branch: String)

Enable git polling for a repository path and branch.

pub fn enable_file_watching(&mut self, root: PathBuf, patterns: Vec<String>)

Enable file watching for source files under a root directory.

pub fn cached_confidence(&self) -> Option<&ConfidenceReport>

Get the cached confidence report from the last recomputation.

pub fn git_poller(&self) -> Option<&GitPoller>

Get a reference to the git poller, if enabled.

pub fn file_watcher(&self) -> Option<&FileWatcher>

Get a reference to the file watcher, if enabled.

pub fn total_ticks(&self) -> u64

Total ticks processed.

pub fn confidence_history(&self) -> &ConfidenceHistory

Get a reference to the confidence history.

pub fn confidence_history_mut(&mut self) -> &mut ConfidenceHistory

Get a mutable reference to the confidence history.

pub fn strategy_tracker(&self) -> &StrategyTracker

Get a reference to the strategy tracker.

pub fn strategy_tracker_mut(&mut self) -> &mut StrategyTracker

Get a mutable reference to the strategy tracker.

pub fn tick_history(&self) -> &TickHistory

Get a reference to the tick history.

pub fn set_tick_interval_ms(&mut self, ms: u32)

Set the current tick interval (for recommendation calculations).

pub fn recommend_tick_interval(&self) -> TickRecommendation

Analyze recent tick history and recommend interval adjustment.

Looks at recent change frequency to determine if the tick interval should be faster, slower, or idle. Thresholds:

• Frequent changes (>10/min): recommend 200ms (fast).
• Moderate changes (1-10/min): recommend 1000ms (default).
• Rare changes (<1/min): recommend 3000ms (slow).
• No changes for 100+ ticks: recommend 5000ms (idle mode).

Trait Implementations

impl SystemService for WeaverEngine

fn name(&self) -> &str

Human-readable service name.

fn service_type(&self) -> ServiceType

Service type category.

fn start<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Start the service.

fn stop<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Box<dyn Error + Send + Sync>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stop the service.

fn health_check<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = HealthStatus> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Perform a health check.