dirsql 0.0.11__tar.gz → 0.0.13__tar.gz

{dirsql-0.0.11 → dirsql-0.0.13}/.github/workflows/python-test.yml

@@ -5,13 +5,19 @@ on:
     branches: [main]
     paths:
       - '**.py'
+      - '**.rs'
       - 'pyproject.toml'
+      - 'Cargo.toml'
+      - 'Cargo.lock'
       - 'uv.lock'
       - 'tests/**'
   pull_request:
     paths:
       - '**.py'
+      - '**.rs'
       - 'pyproject.toml'
+      - 'Cargo.toml'
+      - 'Cargo.lock'
       - 'uv.lock'
       - 'tests/**'
 

dirsql-0.0.13/.npmignore

@@ -0,0 +1,23 @@
+# Source and build artifacts
+src/
+target/
+Cargo.*
+*.rs
+*.toml
+*.lock
+
+# Dev/CI infrastructure
+.claude/
+.github/
+tests/
+python/
+.beads
+.dolt/
+
+# Docs and notes
+AGENTS.md
+SUMMARY.md
+notes/
+
+# Build tools
+justfile

{dirsql-0.0.11 → dirsql-0.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.0.11
+Version: 0.0.13
 Requires-Dist: pytest>=8 ; extra == 'dev'
 Requires-Dist: pytest-describe>=2 ; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23 ; extra == 'dev'

{dirsql-0.0.11 → dirsql-0.0.13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "dirsql"
-version = "0.0.11"
+version = "0.0.13"
 description = "Ephemeral SQL index over a local directory"
 license = "MIT"
 requires-python = ">=3.12"
@@ -25,3 +25,14 @@ dev = [
 
 [tool.maturin]
 features = ["pyo3/extension-module"]
+exclude = [
+    ".github/",
+    ".claude/",
+    "tests/",
+    "notes/",
+    "index.js",
+    "package.json",
+    ".beads",
+    "AGENTS.md",
+    "justfile",
+]

dirsql-0.0.13/src/lib.rs

@@ -0,0 +1,291 @@
+pub mod db;
+pub mod differ;
+pub mod matcher;
+pub mod scanner;
+pub mod watcher;
+
+/// Extract the table name from a CREATE TABLE DDL statement.
+/// Handles: CREATE TABLE name (...), CREATE TABLE IF NOT EXISTS name (...)
+pub fn parse_table_name(ddl: &str) -> Option<String> {
+    let upper = ddl.to_uppercase();
+    let idx = upper.find("CREATE TABLE")?;
+    let rest = &ddl[idx + "CREATE TABLE".len()..].trim_start();
+
+    // Skip optional "IF NOT EXISTS"
+    let rest = if rest.to_uppercase().starts_with("IF NOT EXISTS") {
+        rest["IF NOT EXISTS".len()..].trim_start()
+    } else {
+        rest
+    };
+
+    // Table name is everything up to the first whitespace or '('
+    let name: String = rest
+        .chars()
+        .take_while(|c| !c.is_whitespace() && *c != '(')
+        .collect();
+
+    if name.is_empty() { None } else { Some(name) }
+}
+
+#[cfg(feature = "extension-module")]
+mod python {
+    use crate::db::{Db, Value};
+    use crate::matcher::TableMatcher;
+    use crate::parse_table_name;
+    use crate::scanner::scan_directory;
+    use pyo3::exceptions::PyRuntimeError;
+    use pyo3::prelude::*;
+    use pyo3::types::{PyDict, PyList};
+    use std::collections::HashMap;
+    use std::path::Path;
+    use std::sync::Mutex;
+
+    /// A table definition for DirSQL.
+    #[pyclass(name = "Table", frozen)]
+    struct PyTable {
+        #[pyo3(get)]
+        ddl: String,
+        #[pyo3(get)]
+        glob: String,
+        extract: Py<PyAny>,
+    }
+
+    #[pymethods]
+    impl PyTable {
+        #[new]
+        #[pyo3(signature = (*, ddl, glob, extract))]
+        fn new(ddl: String, glob: String, extract: Py<PyAny>) -> Self {
+            PyTable { ddl, glob, extract }
+        }
+    }
+
+    /// The main DirSQL class. Creates an in-memory SQLite index over a directory.
+    #[pyclass(name = "DirSQL")]
+    struct PyDirSQL {
+        db: Mutex<Db>,
+    }
+
+    #[pymethods]
+    impl PyDirSQL {
+        #[new]
+        #[pyo3(signature = (root, *, tables, ignore=None))]
+        fn new(
+            py: Python<'_>,
+            root: String,
+            tables: Vec<PyRef<'_, PyTable>>,
+            ignore: Option<Vec<String>>,
+        ) -> PyResult<Self> {
+            let db =
+                Db::new().map_err(|e| PyRuntimeError::new_err(format!("DB init error: {}", e)))?;
+
+            // Parse table names from DDLs and create tables
+            let mut table_configs: Vec<(String, String, Py<PyAny>)> = Vec::new();
+            for t in &tables {
+                let table_name = parse_table_name(&t.ddl).ok_or_else(|| {
+                    PyRuntimeError::new_err(format!(
+                        "Could not parse table name from DDL: {}",
+                        t.ddl
+                    ))
+                })?;
+                db.create_table(&t.ddl)
+                    .map_err(|e| PyRuntimeError::new_err(format!("DDL error: {}", e)))?;
+                table_configs.push((table_name, t.glob.clone(), t.extract.clone_ref(py)));
+            }
+
+            // Build glob -> table_name mappings for the scanner
+            let mappings: Vec<(&str, &str)> = table_configs
+                .iter()
+                .map(|(name, glob, _extract): &(String, String, Py<PyAny>)| {
+                    (glob.as_str(), name.as_str())
+                })
+                .collect();
+            let ignore_patterns: Vec<&str> = ignore
+                .as_ref()
+                .map(|v| v.iter().map(|s| s.as_str()).collect())
+                .unwrap_or_default();
+
+            let matcher = TableMatcher::new(&mappings, &ignore_patterns)
+                .map_err(|e| PyRuntimeError::new_err(format!("Glob error: {}", e)))?;
+
+            // Scan directory
+            let root_path = Path::new(&root);
+            let files = scan_directory(root_path, &matcher);
+
+            // Build a lookup from table_name -> extract callable
+            let extract_map: HashMap<String, Py<PyAny>> = table_configs
+                .iter()
+                .map(|(name, _glob, extract): &(String, String, Py<PyAny>)| {
+                    (name.clone(), extract.clone_ref(py))
+                })
+                .collect();
+
+            // Process each file
+            for (file_path, table_name) in &files {
+                // Read file content
+                let content = std::fs::read_to_string(file_path).map_err(|e| {
+                    PyRuntimeError::new_err(format!(
+                        "Failed to read {}: {}",
+                        file_path.display(),
+                        e
+                    ))
+                })?;
+
+                // Compute relative path
+                let rel_path = file_path
+                    .strip_prefix(root_path)
+                    .unwrap_or(file_path)
+                    .to_string_lossy()
+                    .to_string();
+
+                // Call extract
+                let extract_fn = extract_map.get(table_name).ok_or_else(|| {
+                    PyRuntimeError::new_err(format!("No extract function for table {}", table_name))
+                })?;
+
+                let result = extract_fn.call1(py, (rel_path.clone(), content))?;
+                let rows: Vec<HashMap<String, Py<PyAny>>> = result.extract(py)?;
+
+                // Insert rows
+                for (row_index, py_row) in rows.iter().enumerate() {
+                    let row = convert_py_row(py, py_row)?;
+                    db.insert_row(table_name, &row, &rel_path, row_index)
+                        .map_err(|e| PyRuntimeError::new_err(format!("Insert error: {}", e)))?;
+                }
+            }
+
+            Ok(PyDirSQL { db: Mutex::new(db) })
+        }
+
+        /// Execute a SQL query and return results as a list of dicts.
+        fn query(&self, py: Python<'_>, sql: &str) -> PyResult<Py<PyList>> {
+            let db = self
+                .db
+                .lock()
+                .map_err(|e| PyRuntimeError::new_err(format!("Lock error: {}", e)))?;
+            let rows = db
+                .query(sql)
+                .map_err(|e| PyRuntimeError::new_err(format!("Query error: {}", e)))?;
+
+            let result = PyList::empty(py);
+            for row in &rows {
+                let dict = PyDict::new(py);
+                for (key, value) in row {
+                    let py_val = value_to_py(py, value);
+                    dict.set_item(key, py_val)?;
+                }
+                result.append(dict)?;
+            }
+            Ok(result.unbind())
+        }
+    }
+
+    /// Convert a Python dict row to a Rust HashMap<String, Value>.
+    fn convert_py_row(
+        py: Python<'_>,
+        py_row: &HashMap<String, Py<PyAny>>,
+    ) -> PyResult<HashMap<String, Value>> {
+        let mut row: HashMap<String, Value> = HashMap::new();
+        for (key, val) in py_row {
+            let value = py_to_value(py, val)?;
+            row.insert(key.clone(), value);
+        }
+        Ok(row)
+    }
+
+    /// Convert a Python object to a db::Value.
+    fn py_to_value(py: Python<'_>, obj: &Py<PyAny>) -> PyResult<Value> {
+        let bound = obj.bind(py);
+
+        if bound.is_none() {
+            return Ok(Value::Null);
+        }
+
+        // Try bool first (before int, since bool is subclass of int in Python)
+        if bound.is_instance_of::<pyo3::types::PyBool>() {
+            let b: bool = bound.extract()?;
+            return Ok(Value::Integer(if b { 1 } else { 0 }));
+        }
+
+        // Try integer
+        if let Ok(i) = bound.extract::<i64>() {
+            return Ok(Value::Integer(i));
+        }
+
+        // Try float
+        if let Ok(f) = bound.extract::<f64>() {
+            return Ok(Value::Real(f));
+        }
+
+        // Try string
+        if let Ok(s) = bound.extract::<String>() {
+            return Ok(Value::Text(s));
+        }
+
+        // Try bytes
+        if let Ok(b) = bound.extract::<Vec<u8>>() {
+            return Ok(Value::Blob(b));
+        }
+
+        // Fall back to string representation
+        let s = bound.str()?.to_string();
+        Ok(Value::Text(s))
+    }
+
+    /// Convert a db::Value to a Python object.
+    fn value_to_py(py: Python<'_>, value: &Value) -> Py<PyAny> {
+        match value {
+            Value::Null => py.None(),
+            Value::Integer(i) => i.into_pyobject(py).unwrap().into_any().unbind(),
+            Value::Real(f) => f.into_pyobject(py).unwrap().into_any().unbind(),
+            Value::Text(s) => s.into_pyobject(py).unwrap().into_any().unbind(),
+            Value::Blob(b) => b.into_pyobject(py).unwrap().unbind(),
+        }
+    }
+
+    #[pymodule]
+    fn dirsql(m: &Bound<'_, PyModule>) -> PyResult<()> {
+        m.add("__version__", env!("CARGO_PKG_VERSION"))?;
+        m.add_class::<PyTable>()?;
+        m.add_class::<PyDirSQL>()?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_table_name_simple() {
+        assert_eq!(
+            parse_table_name("CREATE TABLE comments (id TEXT)"),
+            Some("comments".to_string())
+        );
+    }
+
+    #[test]
+    fn parse_table_name_if_not_exists() {
+        assert_eq!(
+            parse_table_name("CREATE TABLE IF NOT EXISTS comments (id TEXT)"),
+            Some("comments".to_string())
+        );
+    }
+
+    #[test]
+    fn parse_table_name_no_space_before_paren() {
+        assert_eq!(
+            parse_table_name("CREATE TABLE t(id TEXT)"),
+            Some("t".to_string())
+        );
+    }
+
+    #[test]
+    fn parse_table_name_invalid() {
+        assert_eq!(parse_table_name("NOT A DDL"), None);
+    }
+
+    #[test]
+    fn parse_table_name_empty_after_create_table() {
+        assert_eq!(parse_table_name("CREATE TABLE "), None);
+    }
+}

dirsql-0.0.13/tests/conftest.py

@@ -0,0 +1,38 @@
+import json
+import os
+import tempfile
+
+import pytest
+
+
+@pytest.fixture
+def tmp_dir():
+    """Create a temporary directory for test files."""
+    with tempfile.TemporaryDirectory() as d:
+        yield d
+
+
+@pytest.fixture
+def jsonl_dir(tmp_dir):
+    """Create a temp dir with JSONL files for testing."""
+    # Create a simple JSONL file
+    os.makedirs(os.path.join(tmp_dir, "comments", "abc"), exist_ok=True)
+    os.makedirs(os.path.join(tmp_dir, "comments", "def"), exist_ok=True)
+
+    with open(os.path.join(tmp_dir, "comments", "abc", "index.jsonl"), "w") as f:
+        f.write(json.dumps({"body": "first comment", "author": "alice"}) + "\n")
+        f.write(json.dumps({"body": "second comment", "author": "bob"}) + "\n")
+
+    with open(os.path.join(tmp_dir, "comments", "def", "index.jsonl"), "w") as f:
+        f.write(json.dumps({"body": "another comment", "author": "carol"}) + "\n")
+
+    return tmp_dir
+
+
+@pytest.fixture
+def csv_dir(tmp_dir):
+    """Create a temp dir with a CSV-like file for testing single-row extraction."""
+    with open(os.path.join(tmp_dir, "metadata.json"), "w") as f:
+        json.dump({"title": "My Project", "version": "1.0"}, f)
+
+    return tmp_dir

dirsql-0.0.13/tests/integration/test_dirsql.py

@@ -0,0 +1,346 @@
+"""Integration tests for the DirSQL Python SDK."""
+
+import json
+import os
+
+import pytest
+
+from dirsql import DirSQL, Table
+
+
+def describe_DirSQL():
+    def describe_init():
+        def it_creates_instance_with_tables(jsonl_dir):
+            """DirSQL can be initialized with a root path and table definitions."""
+            db = DirSQL(
+                jsonl_dir,
+                tables=[
+                    Table(
+                        ddl="CREATE TABLE comments (id TEXT, body TEXT, author TEXT)",
+                        glob="comments/**/index.jsonl",
+                        extract=lambda path, content: [
+                            {
+                                "id": os.path.basename(os.path.dirname(path)),
+                                "body": row["body"],
+                                "author": row["author"],
+                            }
+                            for line in content.splitlines()
+                            for row in [json.loads(line)]
+                        ],
+                    ),
+                ],
+            )
+            assert db is not None
+
+        def it_accepts_ignore_patterns(jsonl_dir):
+            """DirSQL accepts an ignore list to skip matching paths."""
+            db = DirSQL(
+                jsonl_dir,
+                ignore=["**/def/**"],
+                tables=[
+                    Table(
+                        ddl="CREATE TABLE comments (id TEXT, body TEXT, author TEXT)",
+                        glob="comments/**/index.jsonl",
+                        extract=lambda path, content: [
+                            {
+                                "id": os.path.basename(os.path.dirname(path)),
+                                "body": row["body"],
+                                "author": row["author"],
+                            }
+                            for line in content.splitlines()
+                            for row in [json.loads(line)]
+                        ],
+                    ),
+                ],
+            )
+            # Only the "abc" directory should be indexed, not "def"
+            results = db.query("SELECT DISTINCT id FROM comments")
+            ids = {r["id"] for r in results}
+            assert ids == {"abc"}
+
+    def describe_query():
+        def it_returns_all_rows(jsonl_dir):
+            """query returns all indexed rows when no WHERE clause."""
+            db = DirSQL(
+                jsonl_dir,
+                tables=[
+                    Table(
+                        ddl="CREATE TABLE comments (id TEXT, body TEXT, author TEXT)",
+                        glob="comments/**/index.jsonl",
+                        extract=lambda path, content: [
+                            {
+                                "id": os.path.basename(os.path.dirname(path)),
+                                "body": row["body"],
+                                "author": row["author"],
+                            }
+                            for line in content.splitlines()
+                            for row in [json.loads(line)]
+                        ],
+                    ),
+                ],
+            )
+            results = db.query("SELECT * FROM comments")
+            assert len(results) == 3
+
+        def it_returns_dicts_with_column_names(jsonl_dir):
+            """Each result row is a dict keyed by column name."""
+            db = DirSQL(
+                jsonl_dir,
+                tables=[
+                    Table(
+                        ddl="CREATE TABLE comments (id TEXT, body TEXT, author TEXT)",
+                        glob="comments/**/index.jsonl",
+                        extract=lambda path, content: [
+                            {
+                                "id": os.path.basename(os.path.dirname(path)),
+                                "body": row["body"],
+                                "author": row["author"],
+                            }
+                            for line in content.splitlines()
+                            for row in [json.loads(line)]
+                        ],
+                    ),
+                ],
+            )
+            results = db.query(
+                "SELECT author FROM comments WHERE body = 'first comment'"
+            )
+            assert len(results) == 1
+            assert results[0]["author"] == "alice"
+
+        def it_filters_with_where_clause(jsonl_dir):
+            """SQL WHERE clauses work correctly on indexed data."""
+            db = DirSQL(
+                jsonl_dir,
+                tables=[
+                    Table(
+                        ddl="CREATE TABLE comments (id TEXT, body TEXT, author TEXT)",
+                        glob="comments/**/index.jsonl",
+                        extract=lambda path, content: [
+                            {
+                                "id": os.path.basename(os.path.dirname(path)),
+                                "body": row["body"],
+                                "author": row["author"],
+                            }
+                            for line in content.splitlines()
+                            for row in [json.loads(line)]
+                        ],
+                    ),
+                ],
+            )
+            results = db.query("SELECT * FROM comments WHERE id = 'abc'")
+            assert len(results) == 2
+            assert all(r["id"] == "abc" for r in results)
+
+        def it_excludes_internal_tracking_columns(jsonl_dir):
+            """Internal _dirsql_* columns are not exposed in query results."""
+            db = DirSQL(
+                jsonl_dir,
+                tables=[
+                    Table(
+                        ddl="CREATE TABLE comments (id TEXT, body TEXT, author TEXT)",
+                        glob="comments/**/index.jsonl",
+                        extract=lambda path, content: [
+                            {
+                                "id": os.path.basename(os.path.dirname(path)),
+                                "body": row["body"],
+                                "author": row["author"],
+                            }
+                            for line in content.splitlines()
+                            for row in [json.loads(line)]
+                        ],
+                    ),
+                ],
+            )
+            results = db.query("SELECT * FROM comments LIMIT 1")
+            assert len(results) == 1
+            row = results[0]
+            assert "_dirsql_file_path" not in row
+            assert "_dirsql_row_index" not in row
+
+        def it_handles_integer_values(tmp_dir):
+            """Integer values in extracted data are preserved correctly."""
+            os.makedirs(os.path.join(tmp_dir, "data"), exist_ok=True)
+            with open(os.path.join(tmp_dir, "data", "counts.json"), "w") as f:
+                json.dump({"name": "apples", "count": 42}, f)
+
+            db = DirSQL(
+                tmp_dir,
+                tables=[
+                    Table(
+                        ddl="CREATE TABLE items (name TEXT, count INTEGER)",
+                        glob="data/*.json",
+                        extract=lambda path, content: [json.loads(content)],
+                    ),
+                ],
+            )
+            results = db.query("SELECT * FROM items")
+            assert len(results) == 1
+            assert results[0]["name"] == "apples"
+            assert results[0]["count"] == 42
+
+    def describe_multiple_tables():
+        def it_supports_multiple_table_definitions(tmp_dir):
+            """Multiple tables can be defined with different globs and extractors."""
+            os.makedirs(os.path.join(tmp_dir, "posts"), exist_ok=True)
+            os.makedirs(os.path.join(tmp_dir, "authors"), exist_ok=True)
+
+            with open(os.path.join(tmp_dir, "posts", "hello.json"), "w") as f:
+                json.dump({"title": "Hello World", "author_id": "1"}, f)
+
+            with open(os.path.join(tmp_dir, "authors", "alice.json"), "w") as f:
+                json.dump({"id": "1", "name": "Alice"}, f)
+
+            db = DirSQL(
+                tmp_dir,
+                tables=[
+                    Table(
+                        ddl="CREATE TABLE posts (title TEXT, author_id TEXT)",
+                        glob="posts/*.json",
+                        extract=lambda path, content: [json.loads(content)],
+                    ),
+                    Table(
+                        ddl="CREATE TABLE authors (id TEXT, name TEXT)",
+                        glob="authors/*.json",
+                        extract=lambda path, content: [json.loads(content)],
+                    ),
+                ],
+            )
+            posts = db.query("SELECT * FROM posts")
+            authors = db.query("SELECT * FROM authors")
+            assert len(posts) == 1
+            assert len(authors) == 1
+            assert posts[0]["title"] == "Hello World"
+            assert authors[0]["name"] == "Alice"
+
+        def it_supports_joins_across_tables(tmp_dir):
+            """SQL JOINs work across different tables."""
+            os.makedirs(os.path.join(tmp_dir, "posts"), exist_ok=True)
+            os.makedirs(os.path.join(tmp_dir, "authors"), exist_ok=True)
+
+            with open(os.path.join(tmp_dir, "posts", "hello.json"), "w") as f:
+                json.dump({"title": "Hello World", "author_id": "1"}, f)
+
+            with open(os.path.join(tmp_dir, "authors", "alice.json"), "w") as f:
+                json.dump({"id": "1", "name": "Alice"}, f)
+
+            db = DirSQL(
+                tmp_dir,
+                tables=[
+                    Table(
+                        ddl="CREATE TABLE posts (title TEXT, author_id TEXT)",
+                        glob="posts/*.json",
+                        extract=lambda path, content: [json.loads(content)],
+                    ),
+                    Table(
+                        ddl="CREATE TABLE authors (id TEXT, name TEXT)",
+                        glob="authors/*.json",
+                        extract=lambda path, content: [json.loads(content)],
+                    ),
+                ],
+            )
+            results = db.query(
+                "SELECT posts.title, authors.name "
+                "FROM posts JOIN authors ON posts.author_id = authors.id"
+            )
+            assert len(results) == 1
+            assert results[0]["title"] == "Hello World"
+            assert results[0]["name"] == "Alice"
+
+    def describe_error_handling():
+        def it_raises_on_invalid_sql(jsonl_dir):
+            """Invalid SQL raises an exception."""
+            db = DirSQL(
+                jsonl_dir,
+                tables=[
+                    Table(
+                        ddl="CREATE TABLE comments (id TEXT, body TEXT, author TEXT)",
+                        glob="comments/**/index.jsonl",
+                        extract=lambda path, content: [
+                            {
+                                "id": os.path.basename(os.path.dirname(path)),
+                                "body": row["body"],
+                                "author": row["author"],
+                            }
+                            for line in content.splitlines()
+                            for row in [json.loads(line)]
+                        ],
+                    ),
+                ],
+            )
+            with pytest.raises(Exception):
+                db.query("NOT VALID SQL")
+
+        def it_raises_on_invalid_ddl(tmp_dir):
+            """Invalid DDL raises an exception during init."""
+            with pytest.raises(Exception):
+                DirSQL(
+                    tmp_dir,
+                    tables=[
+                        Table(
+                            ddl="NOT A CREATE TABLE",
+                            glob="*.json",
+                            extract=lambda path, content: [],
+                        ),
+                    ],
+                )
+
+        def it_handles_empty_directory(tmp_dir):
+            """An empty directory produces zero rows."""
+            db = DirSQL(
+                tmp_dir,
+                tables=[
+                    Table(
+                        ddl="CREATE TABLE items (name TEXT)",
+                        glob="**/*.json",
+                        extract=lambda path, content: [json.loads(content)],
+                    ),
+                ],
+            )
+            results = db.query("SELECT * FROM items")
+            assert len(results) == 0
+
+        def it_handles_extract_returning_empty_list(tmp_dir):
+            """Extract function returning [] produces no rows for that file."""
+            with open(os.path.join(tmp_dir, "skip.json"), "w") as f:
+                json.dump({"ignore": True}, f)
+
+            db = DirSQL(
+                tmp_dir,
+                tables=[
+                    Table(
+                        ddl="CREATE TABLE items (name TEXT)",
+                        glob="**/*.json",
+                        extract=lambda path, content: [],
+                    ),
+                ],
+            )
+            results = db.query("SELECT * FROM items")
+            assert len(results) == 0
+
+    def describe_extract_receives_path_and_content():
+        def it_passes_relative_path_and_string_content(tmp_dir):
+            """Extract receives the file path (relative to root) and content as string."""
+            with open(os.path.join(tmp_dir, "test.json"), "w") as f:
+                json.dump({"val": 1}, f)
+
+            captured = {}
+
+            def extract(path, content):
+                captured["path"] = path
+                captured["content"] = content
+                return [{"val": 1}]
+
+            db = DirSQL(
+                tmp_dir,
+                tables=[
+                    Table(
+                        ddl="CREATE TABLE t (val INTEGER)",
+                        glob="*.json",
+                        extract=extract,
+                    ),
+                ],
+            )
+            db.query("SELECT * FROM t")
+            assert captured["path"] == "test.json"
+            assert '"val"' in captured["content"]

dirsql-0.0.11/index.js

@@ -1,5 +0,0 @@
-"use strict";
-
-module.exports = {
-  message: "dirsql TypeScript SDK is not yet implemented. See https://github.com/thekevinscott/dirsql for status.",
-};

dirsql-0.0.11/justfile

@@ -1,53 +0,0 @@
-# Run all lints
-lint:
-    ruff check .
-
-# Check formatting
-format-check:
-    ruff format --check .
-
-# Auto-format
-format:
-    ruff format .
-
-# Fix lint issues
-fix:
-    ruff check --fix .
-    ruff format .
-
-# Run Python unit tests (colocated)
-test-unit:
-    pytest python/ -x -q
-
-# Run integration tests
-test-integration:
-    pytest tests/integration/ -x -q
-
-# Run e2e tests (local only, not CI)
-test-e2e:
-    pytest tests/e2e/ -x -q
-
-# CI test target (unit + integration, no e2e)
-test-ci:
-    pytest python/ tests/integration/ -x -q --tb=short 2>/dev/null || echo "No tests found yet"
-
-# Run Rust tests
-test-rust:
-    cargo test
-
-# Run Rust clippy
-clippy:
-    cargo clippy -- -D warnings
-
-# Run Rust format check
-fmt-check:
-    cargo fmt -- --check
-
-# Full local CI
-ci:
-    just lint
-    just format-check
-    just clippy
-    just fmt-check
-    just test-rust
-    just test-ci

dirsql-0.0.11/package.json

@@ -1,8 +0,0 @@
-{
-  "name": "dirsql",
-  "version": "0.0.1",
-  "description": "Ephemeral SQL index over a local directory",
-  "license": "MIT",
-  "repository": "https://github.com/thekevinscott/dirsql",
-  "main": "index.js"
-}

dirsql-0.0.11/src/lib.rs

@@ -1,15 +0,0 @@
-pub mod db;
-pub mod differ;
-pub mod matcher;
-pub mod scanner;
-pub mod watcher;
-
-#[cfg(feature = "extension-module")]
-use pyo3::prelude::*;
-
-#[cfg(feature = "extension-module")]
-#[pymodule]
-fn dirsql(m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add("__version__", env!("CARGO_PKG_VERSION"))?;
-    Ok(())
-}