lvkit 0.2.0__tar.gz → 0.2.1__tar.gz

{lvkit-0.2.0 → lvkit-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lvkit
-Version: 0.2.0
+Version: 0.2.1
 Summary: Understand and convert LabVIEW VIs to Python without a LabVIEW license
 Project-URL: Repository, https://github.com/pragmatest-dev/lvkit
 Project-URL: Issues, https://github.com/pragmatest-dev/lvkit/issues

{lvkit-0.2.0 → lvkit-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "lvkit"
-version = "0.2.0"
+version = "0.2.1"
 description = "Understand and convert LabVIEW VIs to Python without a LabVIEW license"
 readme = "README.md"
 requires-python = ">=3.10"

{lvkit-0.2.0 → lvkit-0.2.1}/src/lvkit/cli.py

@@ -496,8 +496,9 @@ def cmd_setup(args: argparse.Namespace) -> int:
         editors = _detect_ai_editors(root)
         if not editors:
             print(
-                "No AI agent detected. Run with --skills claude or --skills copilot "
-                "to install skills explicitly."
+                "No AI agent detected. If you add one later, run `lvkit setup` again. "
+                "If you have one that wasn't detected, run `lvkit setup claude` or "
+                "`lvkit setup copilot` to install skills explicitly."
             )
             return 0
 

{lvkit-0.2.0 → lvkit-0.2.1}/src/lvkit/skill_templates/lvkit-convert/SKILL.md

@@ -107,11 +107,11 @@ lvkit mcp                          # Start MCP server for IDE integration
 The MCP server (`lvkit mcp`) provides tools for interactive exploration:
 
 **Session:**
-- `load_vi` — Load VI into persistent graph
-- `list_loaded_vis` — List loaded VIs
+- `load` — Load VI into persistent graph
+- `list_loaded` — List loaded VIs
 
 **Exploration:**
-- `describe_vi` — Human-readable VI overview (signature, SubVIs, control flow)
+- `describe` — Human-readable VI overview (signature, SubVIs, control flow)
 - `get_operations` — Execution order with nested structures
 - `get_dataflow` — Wire connections, optionally filtered by operation
 - `get_structure` — Case/loop/sequence details
@@ -120,11 +120,11 @@ The MCP server (`lvkit mcp`) provides tools for interactive exploration:
 **Generation:**
 - `generate_ast_code` — Deterministic Python from loaded VI
 - `generate_python` — Full pipeline: load + generate + write files
-- `get_vi_context` — Raw VI context as JSON
+- `get_context` — Raw VI context as JSON
 
 **Documentation:**
 - `generate_documents` — Create HTML documentation
-- `analyze_vi` — Parse and return VI structure
+- `analyze` — Parse and return VI structure
 
 ## Related Skills
 

lvkit-0.2.1/src/lvkit/skill_templates/lvkit-describe/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: lvkit-describe
+description: Describe what a LabVIEW VI does — signature, operations, dataflow, structures, constants. Works via CLI or MCP.
+allowed-tools: Bash, Read, Grep
+---
+
+# Describe VI
+
+Run `lvkit describe` on the VI:
+
+```bash
+lvkit describe "<vi-path>" --search-path "<library-path>"
+```
+
+Add `--chart` to also print a Mermaid flowchart:
+
+```bash
+lvkit describe "<vi-path>" --search-path "<library-path>" --chart
+```
+
+**Report to the user using this format:**
+
+```
+# <VI name>
+
+**What it does:** <1-2 sentence interpretation — purpose, key behavior, notable observations>
+
+**Signature:** `<function signature>`
+
+| Input | Type | Default |
+|---|---|---|
+| <name> | <type> | <default or —> |
+
+| Output | Type |
+|---|---|
+| <name> | <type> |
+
+**Control flow:** <brief description — frames, loops, cases>
+<bulleted breakdown if the structure has meaningful steps>
+
+| Constant | Type | Value |
+|---|---|---|
+| <inferred name or purpose> | <type> | <value> |
+
+| Dependency | Description |
+|---|---|
+| <VI name> | <what it does> |
+
+**Notable:** <surprising things, naming quirks, caveats — omit section if nothing to say>
+```
+
+Rules:
+- Omit any table that has no rows (e.g. no inputs → no inputs table)
+- Collapse repeated dependencies: `DAQmx Write.vi ×3`
+- Use judgment on Constants — infer purpose from context, omit trivial ones
+- Interpretation leads; raw data follows
+
+## MCP alternative
+
+If MCP tools are available, use them directly:
+
+- `load` → `describe` → `get_operations` → `get_dataflow` → `get_structure` → `get_constants`
+
+## Note
+
+`lvkit describe` never requires resolution to succeed. Unknown primitives and vi.lib VIs render as `[prim N]` / their bare name.

{lvkit-0.2.0 → lvkit-0.2.1}/src/lvkit/skill_templates/lvkit-idiomatic/SKILL.md

@@ -18,29 +18,10 @@ The user provides either:
 
 Substitute `<vi-path>` and `<library-path>` with the user's actual paths.
 
-The simplest path is the CLI:
-
 ```bash
 lvkit describe "<vi-path>" --search-path "<library-path>"
 ```
 
-Or programmatically if you need the operations list separately:
-
-```bash
-python3 -c "
-from pathlib import Path
-from lvkit.graph.core import InMemoryVIGraph
-from lvkit.graph.describe import describe_vi, describe_operations
-
-g = InMemoryVIGraph()
-g.load_vi('<vi-path>', search_paths=[Path('<library-path>')])
-vi_name = list(g.list_vis())[0]
-print(describe_vi(g, vi_name))
-print()
-print(describe_operations(g, vi_name))
-"
-```
-
 ## Step 2: Read the generated code
 
 Read the AST-generated Python file. This is the **correct reference** — same behavior required.

lvkit-0.2.0/src/lvkit/skill_templates/lvkit-describe/SKILL.md

@@ -1,108 +0,0 @@
----
-name: lvkit-describe
-description: Describe what a LabVIEW VI does — signature, operations, dataflow, structures, constants. Works via CLI or MCP.
-allowed-tools: Bash, Read, Grep
----
-
-# Describe VI
-
-Understand what a LabVIEW VI does without converting it.
-
-Substitute the placeholders below with the user's actual paths:
-
-- `<vi-path>` — the .vi file you want to describe
-- `<library-path>` — additional search path for SubVI resolution (repeat for multiple)
-- `<vi-name>` — the canonical VI name as it appears in the loaded graph (e.g. `MyLib.lvlib:Foo.vi`)
-- `<operation-id>` — the ID of a specific operation node from the describe output
-
-## Quick path: CLI
-
-The `lvkit describe` CLI is the simplest entry point.
-
-```bash
-lvkit describe "<vi-path>" --search-path "<library-path>"
-```
-
-Add `--chart` to also print a Mermaid flowchart of the dataflow:
-
-```bash
-lvkit describe "<vi-path>" --search-path "<library-path>" --chart
-```
-
-## Programmatic path: Python
-
-For deeper exploration (drilling into a specific operation, listing class methods, etc.) use the graph API directly.
-
-### Overview
-
-```bash
-python3 -c "
-from pathlib import Path
-from lvkit.graph.core import InMemoryVIGraph
-from lvkit.graph.describe import describe_vi, describe_operations, describe_constants
-
-g = InMemoryVIGraph()
-g.load_vi('<vi-path>', search_paths=[Path('<library-path>')])
-vi = list(g.list_vis())[0]
-print(describe_vi(g, vi))
-print()
-print(describe_operations(g, vi))
-print()
-print(describe_constants(g, vi))
-"
-```
-
-### Dataflow for a specific operation
-
-```bash
-python3 -c "
-from pathlib import Path
-from lvkit.graph.core import InMemoryVIGraph
-from lvkit.graph.describe import describe_dataflow
-
-g = InMemoryVIGraph()
-g.load_vi('<vi-path>', search_paths=[Path('<library-path>')])
-print(describe_dataflow(g, '<vi-name>', '<operation-id>'))
-"
-```
-
-### Structure details (case/loop/sequence)
-
-```bash
-python3 -c "
-from pathlib import Path
-from lvkit.graph.core import InMemoryVIGraph
-from lvkit.graph.describe import describe_structure
-
-g = InMemoryVIGraph()
-g.load_vi('<vi-path>', search_paths=[Path('<library-path>')])
-print(describe_structure(g, '<vi-name>', '<operation-id>'))
-"
-```
-
-### Classes — list all methods
-
-```bash
-python3 -c "
-from pathlib import Path
-from lvkit.graph.core import InMemoryVIGraph
-from lvkit.graph.describe import describe_vi
-
-g = InMemoryVIGraph()
-g.load_lvclass('<lvclass-path>', search_paths=[Path('<library-path>')])
-for vi in sorted(g.list_vis()):
-    if '.lvclass:' in vi:
-        print(describe_vi(g, vi))
-        print()
-"
-```
-
-## MCP alternative
-
-If MCP tools are available, use them directly instead of the CLI/Python paths:
-
-- `load_vi` → `describe_vi` → `get_operations` → `get_dataflow` → `get_structure` → `get_constants`
-
-## Note
-
-`lvkit describe` and the underlying graph functions never require resolution to succeed. Unknown primitives and vi.lib VIs render as `[prim N]` / their bare name — you can describe a VI even if lvkit has no mapping for some of its operations.