Fluid Network Solver

Solve and analyze steady incompressible fluid networks from TOML definitions. Use when users ask to design a network template, validate TOML topology data, c...

Security Scan

The skill's code, instructions, and requirements are consistent with a local TOML-driven fluid-network solver; it reads/writes local files and has no hidden network calls or credential demands.

Purpose & Capability

Name/description match the included code: TOML parsing, scenario overrides, numerical solver (scipy fallback), analysis, and report generation. Declared requirements (none) and the listed requirements.txt (scipy, networkx, tomli) are proportional to a numerical solver and topology analysis.

Instruction Scope

SKILL.md instructs running the included CLI script which legitimately needs to read a TOML input and optionally read a report template and write report/JSON outputs. Be aware the CLI accepts arbitrary filesystem paths for the input TOML, report template, and output files, and the code will read and write those paths (Path.resolve(), read_text(), write_text()). This is expected for a CLI tool but means the agent/script can read any file the runtime user has access to and can overwrite files at paths you supply.

Install Mechanism

No install spec is provided (the skill bundle contains Python source). There are no downloads or external installers. The requirements.txt lists common numeric libraries (scipy, networkx, tomli) appropriate for the solver; pulling those via pip is expected for correct execution.

Credentials

The skill does not request environment variables, credentials, or configuration paths. The code does not access environment secrets or network endpoints. Required libraries are proportional to the stated functionality.

Persistence & Privilege

always is false and the skill does not attempt to modify other skills or global agent configuration. It writes files only to paths provided by the user or defaults under the skill assets, which is normal for a CLI tool.

Scan Findings in Context

[no_findings] expected: Static pre-scan reported no injection signals. This aligns with the code being local, readable, and not performing network I/O or subprocess execution.

Assessment

This skill appears to do exactly what it claims: parse a TOML network, run a numerical solver, analyze connectivity, and render reports. Things to consider before installing or running: - Local file access: the CLI reads any TOML you point it to and can read an arbitrary report template path; it also writes report and JSON files to any paths you specify. Only run it with input/output paths you trust and avoid pointing it at sensitive files you don't want read or overwritten. - Dependencies: the solver relies on scipy and networkx; installing/running may require adding these Python packages into the runtime environment. If you run in a managed environment without those packages, execution will fall back to built-in routines where provided, but numerical behavior may differ. - No network exfiltration: there are no HTTP/network calls or credential requirements in the code, and it does not read environment secrets. The main risk surface is local file I/O and the usual hazards of running third-party code locally. If you want higher assurance, inspect the full source locally (which is included here) or run the skill in an isolated environment (container or sandbox) before using it on sensitive data.

Overview

Parse a TOML fluid network, apply named scenario overrides, solve hydraulic steady-state variables, and produce reliability analysis outputs. Use the scripts in this skill for deterministic execution instead of rewriting solver logic each time.

Workflow

1. Read schema details from references/toml_schema.md when defining or checking input.
2. Prepare a TOML file containing system, nodes, pipes, and scenarios.
3. Run scripts/run_fluid_skill.py with one scenario or all scenarios.
4. Return JSON output, markdown report, or a readable console summary.

Parameter Entry

Use this command from the skill root:

python scripts/run_fluid_skill.py --toml <input.toml> [--scenario <name> | --all-scenarios] [--report-out <report.md>] [--json-out <result.json>] [--print-text]

Supported parameters:

• --toml: required input network file.
• --scenario: single scenario name (default base).
• --all-scenarios: analyze base plus all named scenarios.
• --report-template: optional template path, default assets/report_template.md.
• --report-out: optional markdown report output path.
• --json-out: optional JSON result output path.
• --print-text: print readable scenario analysis to stdout.
• --generate-template: optionally write a starter TOML template and exit.

Outputs

Generate these outputs based on user request:

• Plain text analysis: convergence, pressures, flows, and load pass/fail status.
• JSON payload: machine-readable scenario results.
• Markdown report: rendered from assets/report_template.md.

Report Template

Use assets/report_template.md placeholders:

• {{generated_at_utc}}
• {{input_file}}
• {{scenario_mode}}
• {{scenario_count}}
• {{summary_table}}
• {{detail_sections}}

Files

• scripts/fluid_solver_core.py: compatibility shim that re-exports the maintained root implementation.
• scripts/run_fluid_skill.py: CLI entry for parameterized execution and report generation.
• references/toml_schema.md: authoritative schema and sample.
• assets/report_template.md: default report skeleton.
• assets/sample_network.toml: runnable demo network.
• requirements.txt: runtime dependencies for packaging or local execution.

Execution Examples

Run one scenario:

python scripts/run_fluid_skill.py --toml assets/sample_network.toml --scenario Normal_Operation --print-text

Run all scenarios and export report + JSON:

python scripts/run_fluid_skill.py --toml assets/sample_network.toml --all-scenarios --report-out outputs/report.md --json-out outputs/result.json

Generate a template:

python scripts/run_fluid_skill.py --generate-template outputs/template.toml