Fix a few bugs

Author: habedi

README.md

@@ -3,7 +3,7 @@
 [![Tests](https://img.shields.io/github/actions/workflow/status/IssunDB/example-apps/tests.yml?label=tests&style=flat&labelColor=282c34&logo=github)](https://github.com/IssunDB/example-apps/actions/workflows/tests.yml)
 [![Code Coverage](https://img.shields.io/codecov/c/github/IssunDB/example-apps?label=coverage&style=flat&labelColor=282c34&logo=codecov)](https://codecov.io/gh/IssunDB/example-apps)
 [![Python version](https://img.shields.io/badge/python-%3E=3.10-3776ab?style=flat&labelColor=282c34&logo=python)](https://github.com/IssunDB/example-apps)
-[![License: MIT](https://img.shields.io/badge/license-MIT-ffd343?style=flat&labelColor=282c34&logo=open-source-initiative)](LICENSE)
+[![License: MIT](https://img.shields.io/badge/license-MIT-3776ab?style=flat&labelColor=282c34&logo=open-source-initiative)](LICENSE)
 
 This repository includes a collection of example applications that use the [IssunDB](https://github.com/IssunDB/issun-db) graph database.
 

python/fraud/src/fraud_detection_stream/main.py

@@ -101,11 +101,15 @@ def main(argv: list[str] | None = None) -> int:
         if not batch:
             break
         batch_no += 1
+        batch_first_ts = batch[0].ts
         for event in batch:
             store.apply(event)
             last_ts = max(last_ts, event.ts)
 
-        since_ts = last_ts - args.window
+        # Look back `window` seconds, but never start later than the oldest
+        # event in this batch: a batch whose span exceeds the window would
+        # otherwise drop patterns injected early in it before they are scored.
+        since_ts = min(last_ts - args.window, batch_first_ts)
         new_alerts: list[Alert] = []
         for alert in run_all_detectors(db, since_ts):
             key = (alert.rule, alert.subject)

rust/code-explorer/src/main.rs

@@ -38,12 +38,12 @@ enum Command {
     Dead,
     /// Everything transitively affected if this function changes.
     Impact { name: String },
-    /// Most structurally important functions (PageRank over the call graph).
+    /// Most structurally important functions (PageRank over the code graph).
     Rank {
         #[arg(long, default_value_t = 15)]
         top: usize,
     },
-    /// Connected components and recursion cycles in the call graph.
+    /// Connected components and reference cycles across the code graph.
     Structure,
     /// Shortest call path between two functions.
     Path { from: String, to: String },
@@ -176,6 +176,9 @@ fn impact(graph: &Graph, name: &str) -> Result<()> {
 }
 
 fn rank(graph: &Graph, top: usize) -> Result<()> {
+    // PageRank runs over every edge type (CALLS, CONTAINS, METHOD_OF,
+    // IMPLEMENTS), so the score is whole-code-graph centrality, not pure
+    // call-graph importance; we then keep only the Function nodes.
     let scores = graph.page_rank(30, 0.85)?;
     let functions = graph.nodes_by_label("Function")?;
     let mut ranked: Vec<(NodeId, f32)> = functions
@@ -184,7 +187,7 @@ fn rank(graph: &Graph, top: usize) -> Result<()> {
         .collect();
     ranked.sort_by(|a, b| b.1.total_cmp(&a.1));
 
-    println!("most depended-upon functions (PageRank over the call graph):");
+    println!("most central functions (PageRank over the code graph):");
     for (node, score) in ranked.into_iter().take(top) {
         println!(
             "  {score:.5}  {:<36} {}",
@@ -208,8 +211,10 @@ fn structure(graph: &Graph) -> Result<()> {
         sizes.len(),
         &sizes[..sizes.len().min(8)]
     );
+    // detect_cycle spans all edge types; in this schema a cycle is almost
+    // always CALLS recursion, but it is not restricted to it.
     println!(
-        "recursion present: {}",
+        "cycle present: {}",
         if graph.detect_cycle()? { "yes" } else { "no" }
     );
     Ok(())

rust/graphrag-agent/src/ingest.rs

@@ -170,11 +170,10 @@ fn chunk(text: &str) -> Vec<String> {
             current.push_str("\n\n");
         }
         current.push_str(para);
-        // Hard-split oversized paragraphs on word boundaries.
+        // Hard-split oversized paragraphs, cutting only at UTF-8 char
+        // boundaries so multi-byte text never panics the slice.
         while current.len() > CHUNK_MAX {
-            let cut = current[..CHUNK_MAX]
-                .rfind(char::is_whitespace)
-                .unwrap_or(CHUNK_MAX);
+            let cut = split_point(&current);
             let rest = current.split_off(cut);
             chunks.push(std::mem::take(&mut current));
             current = rest.trim_start().to_owned();
@@ -186,6 +185,32 @@ fn chunk(text: &str) -> Vec<String> {
     chunks
 }
 
+/// Byte index at or below `CHUNK_MAX` at which to split a too-long chunk.
+///
+/// Prefers the last whitespace boundary within the limit and always lands on a
+/// UTF-8 char boundary, so a chunk containing multi-byte characters cannot
+/// trigger a panic when sliced. The result is at least 1, so the split loop
+/// always makes progress.
+fn split_point(s: &str) -> usize {
+    if let Some((idx, _)) = s
+        .char_indices()
+        .take_while(|(i, _)| *i <= CHUNK_MAX)
+        .filter(|(_, c)| c.is_whitespace())
+        .last()
+    {
+        if idx > 0 {
+            return idx;
+        }
+    }
+    // No usable whitespace in range: fall back to the largest char boundary
+    // at or below the limit.
+    let mut cut = CHUNK_MAX;
+    while cut > 1 && !s.is_char_boundary(cut) {
+        cut -= 1;
+    }
+    cut
+}
+
 /// Heuristic named-entity extraction: runs of capitalized words.
 ///
 /// A real pipeline would use an NER model or an LLM here; runs of TitleCase
@@ -258,4 +283,19 @@ mod tests {
         assert_eq!(chunks.len(), 1);
         assert!(chunks[0].contains("para three"));
     }
+
+    #[test]
+    fn chunking_splits_multibyte_text_without_panic() {
+        // A whitespace-free run of 3-byte characters: byte CHUNK_MAX lands
+        // mid-character, which a naive byte slice would panic on.
+        let text = "\u{4f60}".repeat(400); // 1200 bytes, 400 chars
+        let chunks = chunk(&text);
+        assert!(
+            chunks.len() > 1,
+            "expected a hard split, got {}",
+            chunks.len()
+        );
+        // No whitespace in the input, so the split is lossless.
+        assert_eq!(chunks.concat().chars().count(), 400);
+    }
 }