fixed formatting

Author: anvanster

.github/workflows/ci.yml

@@ -115,27 +115,18 @@ jobs:
         run: |
           cat > benches/graph_benchmarks.rs << 'EOF'
           use criterion::{criterion_group, criterion_main, Criterion};
-          use codegraph::{CodeGraph, Node, NodeType, Edge, EdgeType};
-
-          fn node_operations(c: &mut Criterion) {
-              c.bench_function("node_creation", |b| {
-                  b.iter(|| {
-                      Node::new(NodeType::Function)
-                  })
-              });
-          }
+          use codegraph::{CodeGraph, NodeType, PropertyMap};
 
           fn graph_operations(c: &mut Criterion) {
               c.bench_function("add_node", |b| {
                   b.iter(|| {
                       let mut graph = CodeGraph::in_memory().unwrap();
-                      let node = Node::new(NodeType::Function);
-                      graph.add_node(node).unwrap();
+                      graph.add_node(NodeType::Function, PropertyMap::new()).unwrap();
                   })
               });
           }
 
-          criterion_group!(benches, node_operations, graph_operations);
+          criterion_group!(benches, graph_operations);
           criterion_main!(benches);
           EOF
       

.gitignore

@@ -1,8 +1,5 @@
 /.specify/
 /specs/
-# Common Rust ignores
-/target/
-/**/*.rs.bk
 # Rust build artifacts
 target/
 output/

CHANGELOG.md

@@ -5,7 +5,7 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.1.0] - 2025-01-02
+## [0.1.0] - 2025-11-01
 
 ### Added
 

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "codegraph"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 authors = ["anvanster"]
 license = "Apache-2.0"

Cargo.toml

@@ -206,7 +206,7 @@ Dual-licensed under MIT or Apache-2.0 (your choice).
 
 ---
 
-**Status**: ✅ **READY FOR INITIAL RELEASE (v0.1.0)**
+**Status**: ✅ **READY FOR INITIAL RELEASE (v0.1.1)**
 
 All constitutional requirements met. All tests passing. Documentation complete.
 Ready for community feedback and contributions.

PROJECT_SUMMARY.md

@@ -31,7 +31,7 @@ codegraph does NOT include built-in language parsers. You integrate your own par
 - 115 tests with comprehensive coverage (39 lib + 70 integration/unit + 6 doctests)
 - Every public API is tested
 - Benchmarks ensure performance targets
-- 97% test coverage on core modules
+- 85% test coverage (983/1158 lines)
 
 ### 🪄 Zero Magic
 **"Explicit over implicit, always."**
@@ -137,7 +137,7 @@ Each layer:
 - **Schema-less Properties**: Flexible JSON properties on nodes and edges
 - **Efficient Queries**: O(1) neighbor lookups with adjacency indexing
 - **Explicit Operations**: No hidden behavior or magical conventions
-- **Comprehensive Tests**: 90%+ test coverage
+- **Comprehensive Tests**: 85% test coverage (983/1158 lines)
 - **Zero Unsafe Code**: Memory-safe by default
 
 ## What We Are (and Aren't)
@@ -195,6 +195,9 @@ cargo clippy -- -D warnings
 
 # Check test coverage
 cargo tarpaulin
+
+# Run all CI checks locally (recommended before pushing)
+./scripts/ci-checks.sh
 ```
 
 ## Examples
@@ -327,7 +330,7 @@ This project follows [Semantic Versioning](https://semver.org/):
 - **v0.x**: API may change between minor versions (with deprecation warnings)
 - **v1.0+**: Stability guaranteed, breaking changes only in major versions
 
-Current version: **0.1.0** (Initial release)
+Current version: **0.1.1** (Initial release + formatting fixes)
 
 ## Support
 

README.md

@@ -1,64 +1,83 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId};
-use codegraph::{CodeGraph, NodeType, EdgeType};
+use codegraph::{CodeGraph, EdgeType, NodeType};
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
 use tempfile::TempDir;
 
 fn bench_node_lookup(c: &mut Criterion) {
     let mut group = c.benchmark_group("node_lookup");
-    
+
     for size in [1000, 10_000, 100_000].iter() {
         let temp_dir = TempDir::new().unwrap();
         let db_path = temp_dir.path().join("bench.graph");
         let mut graph = CodeGraph::open(&db_path).unwrap();
-        
+
         // Populate graph
         let node_ids: Vec<_> = (0..*size)
             .map(|i| {
-                graph.add_node(NodeType::Function, vec![
-                    ("name".to_string(), format!("func_{i}").into()),
-                ].into_iter().collect()).unwrap()
+                graph
+                    .add_node(
+                        NodeType::Function,
+                        vec![("name".to_string(), format!("func_{i}").into())]
+                            .into_iter()
+                            .collect(),
+                    )
+                    .unwrap()
             })
             .collect();
-        
+
         group.bench_with_input(BenchmarkId::new("lookup", size), size, |b, _| {
             let node_id = node_ids[node_ids.len() / 2];
             b.iter(|| {
                 black_box(graph.get_node(node_id).unwrap());
             });
         });
     }
-    
+
     group.finish();
 }
 
 fn bench_neighbor_queries(c: &mut Criterion) {
     let mut group = c.benchmark_group("neighbor_queries");
-    
+
     let temp_dir = TempDir::new().unwrap();
     let db_path = temp_dir.path().join("bench.graph");
     let mut graph = CodeGraph::open(&db_path).unwrap();
-    
+
     // Create a node with varying numbers of neighbors
-    let center_node = graph.add_node(NodeType::Function, Default::default()).unwrap();
-    
+    let center_node = graph
+        .add_node(NodeType::Function, Default::default())
+        .unwrap();
+
     for num_neighbors in [10, 100, 1000].iter() {
         for _i in 0..*num_neighbors {
-            let neighbor = graph.add_node(NodeType::Function, Default::default()).unwrap();
-            graph.add_edge(center_node, neighbor, EdgeType::Calls, Default::default()).unwrap();
+            let neighbor = graph
+                .add_node(NodeType::Function, Default::default())
+                .unwrap();
+            graph
+                .add_edge(center_node, neighbor, EdgeType::Calls, Default::default())
+                .unwrap();
         }
-        
-        group.bench_with_input(BenchmarkId::new("get_neighbors", num_neighbors), num_neighbors, |b, _| {
-            b.iter(|| {
-                black_box(graph.get_neighbors(center_node, codegraph::Direction::Outgoing).unwrap());
-            });
-        });
+
+        group.bench_with_input(
+            BenchmarkId::new("get_neighbors", num_neighbors),
+            num_neighbors,
+            |b, _| {
+                b.iter(|| {
+                    black_box(
+                        graph
+                            .get_neighbors(center_node, codegraph::Direction::Outgoing)
+                            .unwrap(),
+                    );
+                });
+            },
+        );
     }
-    
+
     group.finish();
 }
 
 fn bench_batch_insert(c: &mut Criterion) {
     let mut group = c.benchmark_group("batch_insert");
-    
+
     for size in [100, 1000, 10_000].iter() {
         group.bench_with_input(BenchmarkId::new("nodes", size), size, |b, &size| {
             b.iter_with_setup(
@@ -70,18 +89,28 @@ fn bench_batch_insert(c: &mut Criterion) {
                 },
                 |(mut graph, _temp_dir)| {
                     let nodes: Vec<_> = (0..size)
-                        .map(|i| (NodeType::Function, vec![
-                            ("name".to_string(), format!("func_{i}").into()),
-                        ].into_iter().collect()))
+                        .map(|i| {
+                            (
+                                NodeType::Function,
+                                vec![("name".to_string(), format!("func_{i}").into())]
+                                    .into_iter()
+                                    .collect(),
+                            )
+                        })
                         .collect();
                     black_box(graph.add_nodes_batch(nodes).unwrap());
                 },
             );
         });
     }
-    
+
     group.finish();
 }
 
-criterion_group!(benches, bench_node_lookup, bench_neighbor_queries, bench_batch_insert);
+criterion_group!(
+    benches,
+    bench_node_lookup,
+    bench_neighbor_queries,
+    bench_batch_insert
+);
 criterion_main!(benches);

benches/graph_operations.rs

@@ -64,10 +64,16 @@ fn main() -> codegraph::Result<()> {
     println!("\n--- Querying the graph ---\n");
 
     let file_node = graph.get_node(file_id)?;
-    println!("File node: {}", file_node.properties.get_string("path").unwrap_or("unknown"));
+    println!(
+        "File node: {}",
+        file_node.properties.get_string("path").unwrap_or("unknown")
+    );
 
     let neighbors = graph.get_neighbors(main_id, Direction::Outgoing)?;
-    println!("\nMain function calls/references {} entities:", neighbors.len());
+    println!(
+        "\nMain function calls/references {} entities:",
+        neighbors.len()
+    );
     for neighbor_id in &neighbors {
         let neighbor = graph.get_node(*neighbor_id)?;
         if let Some(name) = neighbor.properties.get_string("name") {
@@ -77,7 +83,10 @@ fn main() -> codegraph::Result<()> {
 
     // Get incoming edges (who calls main?)
     let callers = graph.get_neighbors(main_id, Direction::Incoming)?;
-    println!("\nMain function is contained in {} entities:", callers.len());
+    println!(
+        "\nMain function is contained in {} entities:",
+        callers.len()
+    );
     for caller_id in &callers {
         let caller = graph.get_node(*caller_id)?;
         println!("  - {:?}", caller.node_type);
@@ -88,7 +97,11 @@ fn main() -> codegraph::Result<()> {
     println!("\nEdges from main to helper: {}", edges.len());
     for edge_id in &edges {
         let edge = graph.get_edge(*edge_id)?;
-        println!("  - {} (line: {:?})", edge.edge_type, edge.properties.get_int("line"));
+        println!(
+            "  - {} (line: {:?})",
+            edge.edge_type,
+            edge.properties.get_int("line")
+        );
     }
 
     // Graph statistics