remem-ai 0.6.7

Local-first coding agent memory for Claude Code and OpenAI Codex
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use anyhow::Result;
use serde::Serialize;

use crate::cli::embedding_types::EmbeddingAction;

pub(in crate::cli) fn run_embedding(action: EmbeddingAction) -> Result<()> {
    match action {
        EmbeddingAction::Download { model, json } => {
            let report =
                crate::retrieval::embedding::download_local_embedding_model(model.as_deref())?;
            if json {
                println!("{}", serde_json::to_string_pretty(&report)?);
            } else {
                println!(
                    "Downloaded local embedding model {} ({}, {} dims) into {}.",
                    report.model_id, report.upstream_model, report.dimensions, report.install_dir
                );
                println!("Verified {} model files.", report.files_verified);
            }
            Ok(())
        }
        EmbeddingAction::Status { json } => run_embedding_status(json),
        EmbeddingAction::Backfill {
            batch,
            limit,
            prune,
            json,
        } => {
            super::query::run_embedding_backfill(limit, batch, prune, json)?;
            Ok(())
        }
    }
}

fn run_embedding_status(json: bool) -> Result<()> {
    let provider = crate::retrieval::embedding::embedding_provider_status()?;
    let inventory = crate::retrieval::embedding::local_embedding_inventory()?;
    let report = EmbeddingStatusCliReport {
        configured_provider: provider.configured_provider,
        fallback_provider: provider.fallback_provider,
        active_provider: provider.active_provider,
        active_model_id: provider.active_model_id,
        active_dimensions: provider.active_dimensions,
        degraded: provider.degraded,
        disabled: provider.disabled,
        unavailable_reason: provider.unavailable_reason,
        degradation_reason: provider.degradation_reason,
        model_root: inventory.model_root,
        configured_preset: inventory.configured_preset,
        models: inventory.models,
    };
    if json {
        println!("{}", serde_json::to_string_pretty(&report)?);
    } else {
        println!(
            "Embedding provider: {} -> {}",
            report.configured_provider, report.active_provider
        );
        if let Some(fallback) = &report.fallback_provider {
            println!("Fallback: {}", fallback);
        }
        println!(
            "Active model: {}",
            report.active_model_id.as_deref().unwrap_or("none")
        );
        println!(
            "State: degraded={} disabled={}",
            report.degraded, report.disabled
        );
        if let Some(reason) = &report.unavailable_reason {
            println!("Unavailable: {}", reason);
        } else if let Some(reason) = &report.degradation_reason {
            println!("Degraded: {}", reason);
        }
        println!("Model root: {}", report.model_root);
        println!("Configured preset: {}", report.configured_preset);
        for model in &report.models {
            let state = if model.installed {
                "installed"
            } else {
                "missing"
            };
            println!(
                "  {}: {} ({} dims) {}",
                model.preset, model.model_id, model.dimensions, state
            );
            if let Some(reason) = &model.unavailable_reason {
                println!("    {}", reason);
            }
        }
    }
    Ok(())
}

#[derive(Debug, Clone, PartialEq, Serialize)]
struct EmbeddingStatusCliReport {
    configured_provider: String,
    fallback_provider: Option<String>,
    active_provider: String,
    active_model_id: Option<String>,
    active_dimensions: Option<usize>,
    degraded: bool,
    disabled: bool,
    unavailable_reason: Option<String>,
    degradation_reason: Option<String>,
    model_root: String,
    configured_preset: String,
    models: Vec<crate::retrieval::embedding::LocalEmbeddingModelInventory>,
}