logseq-matryca-parser 0.3.0__tar.gz → 0.3.2__tar.gz

{logseq_matryca_parser-0.3.0 → logseq_matryca_parser-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logseq-matryca-parser
-Version: 0.3.0
+Version: 0.3.2
 Summary: The Logos Protocol: Deterministic Logseq AST parsing for Matryca.ai.
 Project-URL: Homepage, https://github.com/MarcoPorcellato/logseq-matryca-parser
 Project-URL: Bug Tracker, https://github.com/MarcoPorcellato/logseq-matryca-parser/issues
@@ -136,7 +136,7 @@ Logseq Matryca Parser is a deterministic **Stack-Machine engine** that acts as t
 
 ---
 
-## ⚡ Recent superpowers (Waves 4–11)
+## ⚡ Recent superpowers (Waves 4–12)
 
 ### Obsidian-native export
 Compile an entire Logseq graph into an **Obsidian vault layout**: YAML frontmatter from page properties, list body preserved, Logseq `((uuid))` links rewritten to **`[[Page#^anchor]]`**, and trailing **`^block-id`** on referenced blocks. Namespace titles become nested folders (e.g. `Projects/AI/Demo.md`).
@@ -176,6 +176,16 @@ matryca-parse agent-read /path/to/graph --query "quantum"
 
 The agent reads cheap topology now; the registry resolves aliases back to sovereign UUIDs when you wire targeted writes.
 
+### Headless Write Engine & AST Linter (Wave 12)
+The parser is **no longer read-only**. Wave 12 adds a **headless Markdown splicer** ([`agent_writer.py`](src/logseq_matryca_parser/agent_writer.py)): `append_child_to_node` uses AST line numbers and indentation (`(indent_level + 1) × tab_size`) to insert a new bullet **atomically** into the sovereign `.md` file—via `tempfile` + `os.replace`—without Logseq’s fragile HTTP API. Pair **`agent-read`** with **`agent-write`**: X-Ray persists its alias map to **`.matryca_xray_state.json`** at the graph root so stateless CLI invocations can **read, then write** in sequence.
+
+```bash
+matryca-parse agent-read /path/to/graph --tag idea
+matryca-parse agent-write /path/to/graph --alias 0 --content "Follow-up from the agent"
+```
+
+For graph hygiene, **`LogseqGraph.get_broken_references()`** flags nodes whose `((uuid))` block refs point at missing registry targets—structural linting, not regex guessing.
+
 ---
 
 ## 🏗️ Core Capabilities
@@ -188,6 +198,8 @@ The agent reads cheap topology now; the registry resolves aliases back to sovere
 | **FORGE** | JSON, clean Markdown, and **Obsidian** vault serialization (`ObsidianForgeVisitor`, `ForgeExporter.to_obsidian_markdown`). |
 | **LENS Visualizer** | 60FPS interactive graph rendering (10k+ nodes) with Glassmorphism HUD. |
 | **Agent-Native Printing Press** | [`agent_press.py`](src/logseq_matryca_parser/agent_press.py): **`SessionAliasRegistry`** maps session aliases ↔ block UUIDs; **`to_xray_markdown`** emits token-minimal outline text for autonomous agents (`matryca-parse agent-read`). |
+| **Headless Write Engine** | [`agent_writer.py`](src/logseq_matryca_parser/agent_writer.py): **`append_child_to_node`** splices child bullets into on-disk Markdown from AST topology; **`matryca-parse agent-write`** resolves aliases via **`.matryca_xray_state.json`**. |
+| **AST Linters** | **`LogseqGraph.get_broken_references()`** returns originating nodes when `block_refs` target UUIDs absent from the global registry. |
 | **Sovereign AI** | 100% Local. Zero telemetry. Private by design. |
 
 ### Data model — `LogseqNode` task fields
@@ -201,7 +213,7 @@ Each AST block is a `LogseqNode`. Alongside `task_status`, the parser surfaces p
   "task_priority": "A",
   "scheduled_at": 1641600000,
   "deadline_at": 1641772800,
-  "clean_text": "Cut v0.3.0 release"
+  "clean_text": "Cut v0.3.2 release"
 }
 ```
 

{logseq_matryca_parser-0.3.0 → logseq_matryca_parser-0.3.2}/README.md

@@ -100,7 +100,7 @@ Logseq Matryca Parser is a deterministic **Stack-Machine engine** that acts as t
 
 ---
 
-## ⚡ Recent superpowers (Waves 4–11)
+## ⚡ Recent superpowers (Waves 4–12)
 
 ### Obsidian-native export
 Compile an entire Logseq graph into an **Obsidian vault layout**: YAML frontmatter from page properties, list body preserved, Logseq `((uuid))` links rewritten to **`[[Page#^anchor]]`**, and trailing **`^block-id`** on referenced blocks. Namespace titles become nested folders (e.g. `Projects/AI/Demo.md`).
@@ -140,6 +140,16 @@ matryca-parse agent-read /path/to/graph --query "quantum"
 
 The agent reads cheap topology now; the registry resolves aliases back to sovereign UUIDs when you wire targeted writes.
 
+### Headless Write Engine & AST Linter (Wave 12)
+The parser is **no longer read-only**. Wave 12 adds a **headless Markdown splicer** ([`agent_writer.py`](src/logseq_matryca_parser/agent_writer.py)): `append_child_to_node` uses AST line numbers and indentation (`(indent_level + 1) × tab_size`) to insert a new bullet **atomically** into the sovereign `.md` file—via `tempfile` + `os.replace`—without Logseq’s fragile HTTP API. Pair **`agent-read`** with **`agent-write`**: X-Ray persists its alias map to **`.matryca_xray_state.json`** at the graph root so stateless CLI invocations can **read, then write** in sequence.
+
+```bash
+matryca-parse agent-read /path/to/graph --tag idea
+matryca-parse agent-write /path/to/graph --alias 0 --content "Follow-up from the agent"
+```
+
+For graph hygiene, **`LogseqGraph.get_broken_references()`** flags nodes whose `((uuid))` block refs point at missing registry targets—structural linting, not regex guessing.
+
 ---
 
 ## 🏗️ Core Capabilities
@@ -152,6 +162,8 @@ The agent reads cheap topology now; the registry resolves aliases back to sovere
 | **FORGE** | JSON, clean Markdown, and **Obsidian** vault serialization (`ObsidianForgeVisitor`, `ForgeExporter.to_obsidian_markdown`). |
 | **LENS Visualizer** | 60FPS interactive graph rendering (10k+ nodes) with Glassmorphism HUD. |
 | **Agent-Native Printing Press** | [`agent_press.py`](src/logseq_matryca_parser/agent_press.py): **`SessionAliasRegistry`** maps session aliases ↔ block UUIDs; **`to_xray_markdown`** emits token-minimal outline text for autonomous agents (`matryca-parse agent-read`). |
+| **Headless Write Engine** | [`agent_writer.py`](src/logseq_matryca_parser/agent_writer.py): **`append_child_to_node`** splices child bullets into on-disk Markdown from AST topology; **`matryca-parse agent-write`** resolves aliases via **`.matryca_xray_state.json`**. |
+| **AST Linters** | **`LogseqGraph.get_broken_references()`** returns originating nodes when `block_refs` target UUIDs absent from the global registry. |
 | **Sovereign AI** | 100% Local. Zero telemetry. Private by design. |
 
 ### Data model — `LogseqNode` task fields
@@ -165,7 +177,7 @@ Each AST block is a `LogseqNode`. Alongside `task_status`, the parser surfaces p
   "task_priority": "A",
   "scheduled_at": 1641600000,
   "deadline_at": 1641772800,
-  "clean_text": "Cut v0.3.0 release"
+  "clean_text": "Cut v0.3.2 release"
 }
 ```
 

{logseq_matryca_parser-0.3.0 → logseq_matryca_parser-0.3.2}/docs/ARCHITECTURE.md

@@ -82,7 +82,7 @@ title Logseq Matryca Parser — C4 Level 2 (Containers)
 Person(knowledgeWorker, "Knowledge Worker", "Local operator of a sovereign Logseq graph.")
 
 System_Boundary(matrycaEcosystem, "Matryca.ai Ecosystem") {
-    Container(kinetic, "KINETIC", "Typer / Rich CLI", "CLI — export (json, markdown, langchain, langchain-enriched, obsidian), visualize, demo, graph scans, `agent-read` (raw X-Ray stdout), append-only agent writes (`append`).")
+    Container(kinetic, "KINETIC", "Typer / Rich CLI", "CLI — export (json, markdown, langchain, langchain-enriched, obsidian), visualize, demo, graph scans, `agent-read` / `agent-write` (X-Ray + headless splice), weekly append (`append`).")
     Container(logos, "LOGOS", "Python / Pydantic", "Stack-Machine AST engine — LogseqPage and LogseqNode models.")
     Container(synapse, "SYNAPSE", "LangChain / LlamaIndex", "Framework-native exporters with parent-child metadata.")
     Container(lens, "LENS", "NetworkX / PyVis", "Reference-topology visualization to interactive HTML.")
@@ -258,9 +258,15 @@ The KINETIC **`export --format langchain-enriched`** path serializes these docum
 
 Visualization export uses **`pyvis`** with **`force_atlas_2based`** physics, fullscreen canvas, HUD filters, glassmorphism control chrome, and stabilized layout configuration suitable for **large graphs at interactive frame rates** in the browser (product positioning targets fluid exploration of graphs on the order of **10⁴ nodes**).
 
-### 3.4 AGENT WRITER — Append-Only Sandboxing
+### 3.4 AGENT WRITER — Append-Only Sandboxing & Headless Splicer
 
-In the **LLM OS** metaphor, **LOGOS** is the **read path** into the hierarchical “disk”: it materializes Spatial Markdown into a **deterministic AST** that downstream adapters trust. **`agent_writer`** ([`logseq_matryca_parser.agent_writer`](../src/logseq_matryca_parser/agent_writer.py)) is the complementary **bounded write syscall**: a **deterministic**, **configuration-aware** channel that **dynamically reads `config.edn`** (for example **`:journal/page-title-format`**) so filenames and titles align with the vault’s own conventions. Writes use **`open(..., mode="a")`** **append-only** I/O — agents **append** new block material **after** existing bytes; they do **not** rewrite, merge, or re-indent prior content. That discipline keeps **existing topology intact** and avoids corrupting the graph in ways that would break a subsequent **LOGOS** parse or violate the **deterministic AST** contract. Surfaced through the **`append`** command in **KINETIC**, this yields an **enterprise-grade**, inspectable path for agent contributions while **read/export** flows remain the authoritative, topology-preserving contract with the vault.
+In the **LLM OS** metaphor, **LOGOS** is the **read path** into the hierarchical “disk”: it materializes Spatial Markdown into a **deterministic AST** that downstream adapters trust. **`agent_writer`** ([`logseq_matryca_parser.agent_writer`](../src/logseq_matryca_parser/agent_writer.py)) is the complementary **bounded write syscall** with two surfaces:
+
+1. **Weekly append sandbox (`logseq_agent_write`).** A **deterministic**, **configuration-aware** channel that **dynamically reads `config.edn`** (for example **`:journal/page-title-format`**) so filenames and titles align with the vault’s own conventions. Writes use **`open(..., mode="a")`** **append-only** I/O — agents **append** new block material **after** existing bytes; they do **not** rewrite, merge, or re-indent prior content. Surfaced through the **`append`** command in **KINETIC**.
+
+2. **Headless Markdown splicer (`append_child_to_node`).** For **in-place graph mutation** under an existing parent block, the engine resolves `target_uuid` via `LogseqGraph.get_node_by_uuid`, walks to the **deepest last descendant** to obtain a **1-based `line_end` insertion index**, and computes child indentation as **`(target_node.indent_level + 1) × graph.tab_size`** spaces before the `- {content}` bullet prefix. The raw file is split into lines, the new row is inserted at that index, and the result is flushed through a **same-directory `tempfile.mkstemp` + `os.replace`** — an atomic swap that avoids torn reads during concurrent tooling. **KINETIC** exposes this as **`matryca-parse agent-write`**, resolving parent blocks by **`--alias`** (from the X-Ray state file) or **`--target-uuid`**.
+
+Both paths keep **existing topology intact** relative to their contract: append-only journaling never truncates prior bytes; the splicer only inserts one new child line at an AST-derived coordinate so a subsequent **LOGOS** parse remains deterministic.
 
 ### 3.5 FORGE — multi-target serialization (JSON, Markdown, Obsidian)
 
@@ -293,13 +299,21 @@ This keeps **global indexes consistent** without rebuilding the entire graph.
 
 **`graph.query()`** seeds a [`GraphQuery`](../src/logseq_matryca_parser/graph.py) with **all registered nodes**, then applies chainable filters: **`has_tag`**, **`with_priority`**, **`under_parent(parent_uuid)`** (ancestor chain on `path`), **`is_task_state`**, and **`execute()`** returning a materialized list. This is the **programmatic complement** to SQL-less graph inspection — ideal for **batch exporters**, **lint rules**, and **agent planners** that need a typed slice of the outline without ad-hoc traversal code.
 
+#### AST reference linter (`get_broken_references`)
+
+**`LogseqGraph.get_broken_references()`** scans every node in **`_node_registry`**. When **`block_refs`** contains a `((uuid))` target absent from the registry, the **originating node** is collected. Downstream apps (MCP servers, CI, pre-embed hooks) get **structural link validation** aligned with LOGOS identity rules — not brittle regex over raw Markdown.
+
 ### 3.7 AGENT PRESS — Agent-native printing press & X-Ray mode
 
 Human-facing RAG (SYNAPSE enriched chunks, breadcrumbs, inherited properties) optimizes for **embedding geometry** and **retrieval filters**. Autonomous agents running tight **read → plan → write** loops need a different projection: **the fewest tokens per topological fact**. **`agent_press.py`** ([`logseq_matryca_parser.agent_press`](../src/logseq_matryca_parser/agent_press.py)) implements the **Printing Press** paradigm: compress the in-memory AST for machine consumption **without** sacrificing parent–child shape.
 
+#### Stateful session registry (`.matryca_xray_state.json`)
+
+X-Ray is designed for **stateless LLM toolchains**: each `agent-read` invocation is a fresh process, yet agents must still **write back** to blocks they only saw as `[n]` tokens. After **`generate_aliases`**, **KINETIC** persists the alias map to **`<graph_root>/.matryca_xray_state.json`** via **`SessionAliasRegistry.save_to_disk`**. A later **`matryca-parse agent-write --alias N`** loads that JSON with **`load_from_disk`**, resolves `N → uuid`, and hands off to **`append_child_to_node`**. The read/write pair therefore composes as **two independent CLI exits** without stuffing UUIDs into the model context — the filesystem holds session continuity.
+
 #### Session alias mechanics (`SessionAliasRegistry`)
 
-`SessionAliasRegistry` is a **session-scoped, in-RAM translation table** between lightweight aliases and sovereign block identities:
+`SessionAliasRegistry` is a **session-scoped translation table** (in-RAM during a single command, rehydratable from disk across commands) between lightweight aliases and sovereign block identities:
 
 | Operation | Role |
 | --------- | ---- |
@@ -323,18 +337,26 @@ Heavy Logseq identifiers (`id:: 64a8b0c1-d33b-4448-a261-e4dc2bbe12d3`, synthetic
 
 No YAML, no JSON wrappers, no collapsed-state metadata, no blank separator lines — **pure topology + semantics** for the LLM “CPU” to load into its context window.
 
-#### KINETIC `agent-read` — Rich bypass for machine stdout
+#### KINETIC `agent-read` / `agent-write` — Rich bypass for machine stdout
+
+The compound CLI commands **`agent_read`** and **`agent_write`** in [`kinetic.py`](../src/logseq_matryca_parser/kinetic.py) are the operator surfaces for the **Headless CRUD** loop:
 
-The compound CLI command **`agent_read`** in [`kinetic.py`](../src/logseq_matryca_parser/kinetic.py) (`matryca-parse agent-read`) is the operator surface for X-Ray ingestion:
+**`matryca-parse agent-read`**
 
 1. **`LogseqGraph.load_directory`** — materialize the RAM image of the vault.
 2. **Filter** — `graph.query().has_tag(tag).execute()` when `--tag` is set; otherwise `search_content(query)` when `--query` is set; otherwise all registered nodes.
-3. **`SessionAliasRegistry.generate_aliases`** → **`to_xray_markdown`**.
+3. **`SessionAliasRegistry.generate_aliases`** → **`save_to_disk(.matryca_xray_state.json)`** → **`to_xray_markdown`**.
 4. **Emit via `sys.stdout.write`** — deliberately **not** Typer’s Rich `Console`.
 
-Rich styling injects **ANSI escape sequences** that waste tokens and can cause models to **hallucinate markup** as content. `agent-read` is **stdout-pure** so shell pipelines, MCP tools, and headless agents receive **unescaped plain text** only. Human-oriented commands (`scan`, `export`, `visualize`) keep Rich; the **machine-native read path** opts out.
+**`matryca-parse agent-write`**
+
+1. Reload the graph (fresh AST coordinates after any external edits).
+2. Resolve **`--alias`** through the persisted registry (or accept **`--target-uuid`** directly).
+3. **`append_child_to_node`** — atomic Markdown splice at the parent’s AST line index.
+
+Rich styling injects **ANSI escape sequences** that waste tokens and can cause models to **hallucinate markup** as content. `agent-read` is **stdout-pure** so shell pipelines, MCP tools, and headless agents receive **unescaped plain text** only. Human-oriented commands (`scan`, `export`, `visualize`) keep Rich; the **machine-native read/write paths** opt out where token fidelity matters.
 
-This complements §3.4 **AGENT WRITER** (append-only human/agent notes) and §3.2 **SYNAPSE** (human/RAG chunking): one stack, three projections — **enriched chunks for vectors**, **X-Ray for agent context**, **append for durable writes**.
+This complements §3.4 **AGENT WRITER** (weekly append + headless splice) and §3.2 **SYNAPSE** (human/RAG chunking): one stack, multiple projections — **enriched chunks for vectors**, **X-Ray + alias state for agent context**, **append / splice for durable writes**.
 
 ---
 

{logseq_matryca_parser-0.3.0 → logseq_matryca_parser-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "logseq-matryca-parser"
-version = "0.3.0"
+version = "0.3.2"
 description = "The Logos Protocol: Deterministic Logseq AST parsing for Matryca.ai."
 readme = "README.md"
 requires-python = ">=3.12"

{logseq_matryca_parser-0.3.0 → logseq_matryca_parser-0.3.2}/src/logseq_matryca_parser/__init__.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 import sys
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"
 
 from .agent_writer import LogseqConfigReader, logseq_agent_write
 from .exceptions import BlockReferenceError, LogseqIndentationError, LogseqParserError

{logseq_matryca_parser-0.3.0 → logseq_matryca_parser-0.3.2}/src/logseq_matryca_parser/agent_press.py

@@ -10,6 +10,8 @@ from logseq_matryca_parser.logos_core import LogseqNode
 
 logger = logging.getLogger(__name__)
 
+XRAY_STATE_FILENAME = ".matryca_xray_state.json"
+
 
 def _flatten_subtrees(nodes: list[LogseqNode]) -> list[LogseqNode]:
     """Depth-first list of nodes under each root, preserving outline order."""

{logseq_matryca_parser-0.3.0 → logseq_matryca_parser-0.3.2}/src/logseq_matryca_parser/kinetic.py

@@ -503,7 +503,11 @@ def agent_read(
     query: str | None = typer.Option(None, "--query", help="Substring search on clean_text."),
 ) -> None:
     """Load a graph, filter nodes, and print ultra-dense X-Ray text to stdout (no Rich)."""
-    from logseq_matryca_parser.agent_press import SessionAliasRegistry, to_xray_markdown
+    from logseq_matryca_parser.agent_press import (
+        SessionAliasRegistry,
+        XRAY_STATE_FILENAME,
+        to_xray_markdown,
+    )
     from logseq_matryca_parser.graph import LogseqGraph
 
     if not graph_path.exists() or not graph_path.is_dir():
@@ -520,6 +524,9 @@ def agent_read(
 
     registry = SessionAliasRegistry()
     registry.generate_aliases(nodes)
+    state_path = graph_path.resolve() / XRAY_STATE_FILENAME
+    registry.save_to_disk(state_path)
+
     output = to_xray_markdown(nodes, registry)
     if output:
         sys.stdout.write(output)
@@ -527,5 +534,70 @@ def agent_read(
             sys.stdout.write("\n")
 
 
+@app.command("agent-write")
+def agent_write(
+    graph_path: Path = typer.Argument(..., help="Path to the Logseq graph root."),
+    content: str = typer.Option(..., "--content", help="Markdown body for the new child bullet."),
+    alias: int | None = typer.Option(
+        None,
+        "--alias",
+        help="Session alias from a prior agent-read (resolved via .matryca_xray_state.json).",
+    ),
+    target_uuid: str | None = typer.Option(
+        None,
+        "--target-uuid",
+        help="Parent block UUID (bypasses alias registry).",
+    ),
+    state_file: Path | None = typer.Option(
+        None,
+        "--state-file",
+        help="Alias registry JSON (default: <graph>/.matryca_xray_state.json).",
+    ),
+) -> None:
+    """Append a child block under a parent via headless AST markdown splicing."""
+    from logseq_matryca_parser.agent_press import SessionAliasRegistry, XRAY_STATE_FILENAME
+    from logseq_matryca_parser.agent_writer import append_child_to_node
+    from logseq_matryca_parser.graph import LogseqGraph
+
+    if alias is None and target_uuid is None:
+        print("Provide --alias or --target-uuid.", file=sys.stderr)
+        raise typer.Exit(code=1)
+    if alias is not None and target_uuid is not None:
+        print("Use only one of --alias or --target-uuid.", file=sys.stderr)
+        raise typer.Exit(code=1)
+
+    if not graph_path.exists() or not graph_path.is_dir():
+        print(f"Invalid graph path: {graph_path}", file=sys.stderr)
+        raise typer.Exit(code=1)
+
+    graph = LogseqGraph.load_directory(graph_path.resolve())
+
+    parent_uuid = target_uuid
+    if alias is not None:
+        registry_path = state_file or (graph_path.resolve() / XRAY_STATE_FILENAME)
+        if not registry_path.is_file():
+            print(f"Alias state file not found: {registry_path}", file=sys.stderr)
+            raise typer.Exit(code=1)
+        registry = SessionAliasRegistry.load_from_disk(registry_path)
+        parent_uuid = registry.resolve_alias(alias)
+        if parent_uuid is None:
+            print(f"Unknown alias: {alias}", file=sys.stderr)
+            raise typer.Exit(code=1)
+
+    assert parent_uuid is not None
+    try:
+        append_child_to_node(graph, parent_uuid, content)
+    except ValueError as exc:
+        print(str(exc), file=sys.stderr)
+        raise typer.Exit(code=1) from exc
+
+    console.print(
+        f"[bold green]Appended child under[/] {parent_uuid}",
+        no_wrap=True,
+        overflow="ignore",
+        crop=False,
+    )
+
+
 if __name__ == "__main__":
     app()

{logseq_matryca_parser-0.3.0 → logseq_matryca_parser-0.3.2}/tests/test_agent_press.py

@@ -115,3 +115,38 @@ def test_agent_read_cli_plain_stdout(tmp_path: Path) -> None:
     assert "\x1b[" not in result.output
     assert "[0]" in result.output
     assert "X-Ray target" in result.output
+
+    state_path = graph_root / ".matryca_xray_state.json"
+    assert state_path.is_file()
+    restored = SessionAliasRegistry.load_from_disk(state_path)
+    assert restored.resolve_alias(0) is not None
+
+
+def test_agent_write_cli_splices_via_alias_state(tmp_path: Path) -> None:
+    graph_root = tmp_path / "graph"
+    pages = graph_root / "pages"
+    pages.mkdir(parents=True)
+    (graph_root / "journals").mkdir()
+    (pages / "Write.md").write_text("- Parent #parent-tag\n", encoding="utf-8")
+
+    read_result = runner.invoke(
+        app,
+        ["agent-read", str(graph_root), "--tag", "parent-tag"],
+    )
+    assert read_result.exit_code == 0
+
+    write_result = runner.invoke(
+        app,
+        [
+            "agent-write",
+            str(graph_root),
+            "--alias",
+            "0",
+            "--content",
+            "Child from agent-write",
+        ],
+    )
+    assert write_result.exit_code == 0
+
+    updated = (pages / "Write.md").read_text(encoding="utf-8")
+    assert "Child from agent-write" in updated

{logseq_matryca_parser-0.3.0 → logseq_matryca_parser-0.3.2}/uv.lock

@@ -864,7 +864,7 @@ wheels = [
 
 [[package]]
 name = "logseq-matryca-parser"
-version = "0.3.0"
+version = "0.3.2"
 source = { editable = "." }
 dependencies = [
     { name = "pydantic" },