qualia_cli/ingest/
agent_intent.rs

1use std::fs::File;
2use std::io::{BufRead, BufReader};
3use std::path::Path;
4
5use qualia_core_db::external_sort::ExternalSorter;
6use qualia_core_db::modalities::defeasible::{evaluate_defeasible_frame, DefeasibleVerdict};
7use qualia_core_db::modalities::epistemic::{
8    check_node_locks, evaluate_epistemic_frame, EpistemicError, EpistemicVerdict,
9};
10use qualia_core_db::modalities::logic::n3logic::infer_logic_bindings;
11use qualia_core_db::modalities::temporal_ltl::{
12    evaluate_lock_lease, evaluate_ltl_trace, LtlFormula, TemporalError,
13};
14use qualia_core_db::q_hash;
15use qualia_core_db::NQuin;
16
17use serde_json::Value;
18
19use qualia_core_db::specialized_libs::chemistry_modeling::ChemistryModelingLibrary;
20use qualia_core_db::specialized_libs::cryptographic_library::CryptographicLibrary;
21use qualia_core_db::specialized_libs::medical_computing::MedicalComputingLibrary;
22use qualia_core_db::specialized_libs::physics_simulation::PhysicsSimulationLibrary;
23
24use crate::ingest::IngestStats;
25
26pub fn ingest_agent_intent(
27    input: &Path,
28    output: &Path,
29) -> Result<IngestStats, Box<dyn std::error::Error>> {
30    let reader = BufReader::new(File::open(input)?);
31    let lines = reader.lines();
32
33    let temp_dir = std::env::temp_dir().join("qualia_sort_agent_intent");
34    let mut sorter = ExternalSorter::new(temp_dir);
35    let mut triples: u64 = 0;
36
37    let mut buffer = Vec::new();
38
39    for raw_line in lines {
40        let line = raw_line?;
41        let line = line.trim();
42        if line.is_empty() {
43            continue;
44        }
45
46        let subject = q_hash("did:q42:agent");
47
48        if let Ok(parsed) = serde_json::from_str::<Value>(line) {
49            let fields = [
50                ("who", "q42:hasAgent"),
51                ("when", "q42:hasTimestamp"),
52                ("why", "q42:hasPurpose"),
53                ("what", "q42:actionPayload"),
54                ("where", "q42:hasLocation"),
55                ("cost", "q42:hasCost"),
56            ];
57
58            for (json_key, pred_iri) in fields {
59                if let Some(val) = parsed.get(json_key) {
60                    let val_str = if val.is_string() {
61                        val.as_str().unwrap().to_string()
62                    } else {
63                        val.to_string()
64                    };
65
66                    let predicate = q_hash(pred_iri);
67                    let object = q_hash(&val_str);
68                    let quin = NQuin {
69                        subject,
70                        predicate,
71                        object,
72                        context: 0,
73                        metadata: 0,
74                        parity: NQuin::calculate_parity(subject, predicate, object, 0, 0),
75                    };
76                    buffer.push(quin);
77                    sorter.push(quin)?;
78                    triples += 1;
79                }
80            }
81        }
82    }
83
84    println!("Inferring routing logic via N3Logic Engine...");
85    let logic_bindings = match infer_logic_bindings(&buffer) {
86        Ok(bindings) => bindings,
87        Err(e) => {
88            return Err(format!("N3Logic Pre-flight Failed: {:?}", e).into());
89        }
90    };
91    println!("Inferred Logic Bindings: {:?}", logic_bindings);
92
93    if logic_bindings.contains(&"modality:temporal") {
94        println!("Dispatching Temporal Logic Check...");
95        let formula = LtlFormula::Globally(q_hash("q42:actionPayload"));
96        let _valid = evaluate_ltl_trace(&buffer, &formula);
97
98        println!("Evaluating Lock Leases...");
99        let current_time = std::time::SystemTime::now()
100            .duration_since(std::time::UNIX_EPOCH)
101            .unwrap()
102            .as_secs();
103        let lock_granted_at = current_time.saturating_sub(100);
104        let ttl_seconds = 300;
105
106        if let Err(TemporalError::AbortedTimeout) =
107            evaluate_lock_lease(lock_granted_at, current_time, ttl_seconds)
108        {
109            println!("STATUS_ABORTED_TIMEOUT: Lock lease expired.");
110        }
111    }
112
113    if logic_bindings.contains(&"modality:epistemic") {
114        println!("Dispatching Epistemic Logic Check...");
115        let agent_did = q_hash("did:q42:agent");
116
117        let mut epistemic_out = vec![
118            EpistemicVerdict {
119                claim: NQuin::default(),
120                status: qualia_core_db::modalities::epistemic::EpistemicStatus::Skipped,
121                certainty: 0,
122            };
123            buffer.len()
124        ];
125        let _ = evaluate_epistemic_frame(&buffer, 0, 0, &mut epistemic_out);
126
127        println!("Checking Sub-Graph Locks (Sandbox Isolation)...");
128        let current_graph = vec![];
129        match check_node_locks(&buffer, &current_graph, agent_did) {
130            Ok(_) => println!("Lock acquisition valid."),
131            Err(EpistemicError::NodeLocked(node)) => {
132                return Err(format!(
133                    "ERROR_NODE_LOCKED: Node {} is currently locked by another agent.",
134                    node
135                )
136                .into());
137            }
138            _ => {}
139        }
140    }
141
142    if logic_bindings.contains(&"modality:defeasible") {
143        println!("Dispatching Defeasible Logic Check...");
144        let mut defeasible_out = vec![
145            DefeasibleVerdict {
146                claim: NQuin::default(),
147                status: qualia_core_db::modalities::defeasible::DefeasibleStatus::Strict,
148            };
149            buffer.len()
150        ];
151        let _ = evaluate_defeasible_frame(&buffer, 0, &mut defeasible_out);
152    }
153
154    if logic_bindings.contains(&"modality:geometric_algebra") {
155        println!("Dispatching Geometric Algebra (PGA) SIMD Kernels...");
156        // Placeholder for geometric algebra execution if available
157    }
158
159    if logic_bindings.contains(&"modality:solver:calculus") {
160        println!("Dispatching Calculus Solver...");
161        // Placeholder for calculus solver if available
162    }
163
164    if logic_bindings.contains(&"modality:paraconsistent") {
165        println!("Dispatching Paraconsistent Logic (Contradiction Isolation)...");
166        // Handled via the paraconsistent isolation route
167    }
168
169    if logic_bindings.contains(&"modality:spatio_temporal") {
170        println!("Dispatching Spatio-Temporal Matrices...");
171        // Handled via spatio_temporal library
172    }
173
174    // Specialized Libraries Hooks
175    if logic_bindings.contains(&"modality:specialized:chemistry") {
176        println!("Dispatching Specialized Library: Chemistry Modeling...");
177        let _lib = ChemistryModelingLibrary::new();
178    }
179    if logic_bindings.contains(&"modality:specialized:physics") {
180        println!("Dispatching Specialized Library: Physics Simulation...");
181        let _lib = PhysicsSimulationLibrary::new();
182    }
183    if logic_bindings.contains(&"modality:specialized:medical") {
184        println!("Dispatching Specialized Library: Medical Computing...");
185        let _lib = MedicalComputingLibrary::new();
186    }
187    if logic_bindings.contains(&"modality:specialized:crypto") {
188        println!("Dispatching Specialized Library: Cryptography...");
189        let _lib = CryptographicLibrary::new();
190    }
191
192    let block_seq = sorter.merge(output)?;
193
194    Ok(IngestStats {
195        triples_ingested: triples,
196        blocks_written: block_seq,
197        lex_entries: 0,
198        lines_skipped: 0,
199        bidx_written: true,
200    })
201}
qualia_cli/ingest/agent_intent.rs

qualia_cli/ingest/
agent_intent.rs
