[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"project-105268":3},{"id":4,"name":5,"fullName":6,"owner":7,"repo":5,"description":8,"homepage":9,"htmlUrl":10,"language":11,"languages":10,"totalLinesOfCode":10,"stars":12,"forks":13,"watchers":14,"openIssues":15,"contributorsCount":16,"subscribersCount":16,"size":16,"stars1d":16,"stars7d":16,"stars30d":16,"stars90d":16,"forks30d":16,"starsTrendScore":16,"compositeScore":17,"rankGlobal":10,"rankLanguage":10,"license":18,"archived":19,"fork":19,"defaultBranch":20,"hasWiki":19,"hasPages":19,"topics":21,"createdAt":10,"pushedAt":35,"updatedAt":36,"readmeContent":37,"aiSummary":38,"trendingCount":16,"starSnapshotCount":16,"syncStatus":15,"lastSyncTime":39,"discoverSource":40},105268,"SignalWeave","fatihfurkan46\u002FSignalWeave","fatihfurkan46","Signal weaving toolkit - combine noisy service metrics into stable, explainable health signals","",null,"Python",58,13,3,2,0,43.44,"Other",false,"main",[22,23,24,25,26,27,28,29,30,31,32,33,34],"alerting","analysis","cli","data","devops","health-check","metrics","monitoring","observability","python","reliability","signals","tooling","2026-10-27 20:20:23","2026-11-01 00:17:51","\u003Cp align=\"center\">\n  \u003Cimg src=\"docs\u002Fassets\u002Flogo.svg\" alt=\"SignalWeave logo: indigo warp threads and amber weft threads interlacing into one central junction\" width=\"150\"\u002F>\n\u003C\u002Fp>\n\n# SignalWeave\n\nEvery AI framework emits telemetry in its own shape. LangChain calls it `lc_run_id` and `latency_ms`; an OpenTelemetry span calls it `trace_id` and `start_time`; a graph runner calls it `session` and `elapsed_ms`. SignalWeave reads those heterogeneous events and weaves them onto one canonical `Signal`, then groups signals by run and reports reliability, quality, and cost indicators. Nothing is dropped: an unrecognized shape falls through to a permissive generic adapter.\n\nIt runs on the Python standard library only, reads from a file or stdin, and writes to stdout, so it drops into a shell pipeline without ceremony.\n\n## Pipeline\n\n![SignalWeave pipeline: four vendor event families collapse into normalize, then aggregate, then report](docs\u002Fassets\u002Fpipeline.svg)\n\nFour stages, each a subcommand:\n\n```bash\n# Canonical signals, one JSON object per line.\npython -m signalweave normalize examples\u002Fevents.jsonl\n\n# Group into runs and emit the aggregate JSON.\npython -m signalweave aggregate examples\u002Fevents.jsonl\n\n# Full weave report (text by default, or --format json).\npython -m signalweave report examples\u002Fevents.jsonl\n\n# Everything for one run, in detail.\npython -m signalweave inspect examples\u002Fevents.jsonl --run-id run-gamma\n```\n\nInput is either a JSON array of event objects or newline-delimited JSON (JSONL). Pass `-` (or omit the path) to read stdin, which lets you chain stages or pipe from another tool.\n\n## How normalization works\n\n`normalize.py` detects a source family per event, either from an explicit `source` or `vendor` field or from structural fingerprints (`span_kind` points to OpenTelemetry, `lc_run_id` to LangChain, `graph_node` to a graph runner, `tool_name` plus `invocation_type` to an agent toolkit). Each family has a small adapter that maps its field names onto the canonical model; anything unmatched uses `_adapter_generic`.\n\nThe canonical `Signal` is flat and serializes to compact, diff-friendly JSON:\n\n| Field | Meaning |\n|-------|---------|\n| `signal_id` | Deterministic `sig_\u003Chash>` from run, name, timestamp, ordinal |\n| `run_id` | The workflow run this signal belongs to |\n| `kind` | `invocation`, `tool`, `retrieval`, `evaluation`, `error`, or `lifecycle` |\n| `name` | Step name (node, tool, operation) |\n| `ts` | Epoch milliseconds, coerced from seconds, ISO-8601, or raw numbers |\n| `duration_ms` | Wall-clock duration |\n| `severity` | `ok`, `notice`, `warn`, `error`, `critical` |\n| `quality` | Clamped 0..1 score when present, else null |\n| `tokens_in` \u002F `tokens_out` | Token counts |\n| `source` | Detected vendor family |\n| `attributes` | Passthrough of vendor-specific fields |\n\n`SignalKind.coerce` and `Severity.coerce` map common vendor vocabularies onto the canonical enums (for example `llm`, `chat`, and `completion` all become `invocation`; `warning` becomes `warn`). The full field reference lives in [docs\u002FSCHEMA.md](docs\u002FSCHEMA.md).\n\nNormalization is deterministic: `normalize_stream` sorts by `(ts, run_id, name, signal_id)`, so the same input always yields the same output regardless of arrival order.\n\n## Indicators\n\n`aggregate.py` groups signals by `run_id` and computes three families of indicators, all as pure functions:\n\n- **Volume**: signal counts by kind, token totals, wall-clock span, and `p50` \u002F `p95` durations.\n- **Quality**: mean and minimum quality across scored signals.\n- **Reliability**: a 0 to 100 score that starts at 100 and subtracts a severity penalty (mean severity weight per signal, scaled and capped at 60) and a latency-stability penalty (the coefficient of variation of durations, capped at 20).\n\nSeverity weights are `ok 0, notice 1, warn 3, error 7, critical 12`. The fabric-wide `RunGroup` carries `run_count`, `signal_count`, token totals, `fabric_reliability` (the mean of per-run reliability), and `fabric_quality_mean`.\n\n## Reports\n\n`report.py` renders an aggregate two ways, both byte-for-byte reproducible across machines:\n\n- `--format text` prints a fixed-width banner, a per-run table (signals, errors, reliability with an ASCII meter, quality, `p50`, `p95`), and a fabric-wide kind distribution.\n- `--format json` emits the `RunGroup` with sorted keys and stable separators.\n\n## Native aggregation core\n\n`engine\u002Fsignal_aggregate.cpp` is a dependency-free C++17 companion. It reads canonical signals as JSONL on stdin (the exact output of `signalweave normalize`) and emits a per-run reliability aggregate, mirroring `signalweave.aggregate` so the native and Python paths agree.\n\n```bash\nmake engine                         # build engine\u002Fsignal_aggregate\nmake parity                         # normalize | .\u002Fsignal_aggregate\n```\n\n## Example data\n\n`examples\u002Fevents.jsonl` carries four runs across four vendor shapes: `run-alpha` (LangChain), `run-beta` (agent toolkit), `run-gamma` (graph runner, including a critical guardrail error), and `run-delta` (generic evaluation and lifecycle events). `examples\u002Fevents_array.json` holds the same style of data as a JSON array, exercising the array input path.\n\n## Make targets\n\n| Target | Action |\n|--------|--------|\n| `make check` | Byte-compile the `signalweave` package |\n| `make normalize` | Normalize the fixture |\n| `make aggregate` | Aggregate the fixture |\n| `make report` | Render the text report |\n| `make engine` | Build the C++ core |\n| `make parity` | Pipe Python normalize output through the native core |\n\nThe `.github\u002Fworkflows\u002Fci.yml` lane compiles the Python package and builds the C++ engine with no network access.\n\n## Module map\n\n- `model.py`: `Signal`, `SignalKind`, `Severity`, and the deterministic `make_signal_id`.\n- `normalize.py`: source detection, the per-vendor adapters, and `normalize_stream`.\n- `aggregate.py`: `RunSummary`, `RunGroup`, reliability and percentile math.\n- `report.py`: text and JSON renderers.\n- `cli.py`: the argparse command surface (`normalize`, `aggregate`, `report`, `inspect`).\n\n## License\n\nSee [LICENSE](LICENSE).\n","SignalWeave 是一个轻量级信号归一化与聚合工具，用于将来自不同 AI\u002F可观测性框架（如 LangChain、OpenTelemetry、图执行器等）的异构服务事件，统一映射为结构一致、语义明确的健康信号（Signal）。其核心功能包括基于指纹自动识别事件源、字段标准化、按运行（run）分组聚合、以及生成可靠性\u002F质量\u002F成本等可解释指标；纯 Python 标准库实现，支持文件或 stdin 输入、stdout 输出，无缝集成 shell 管道。适用于 AI 应用可观测性建设、LLM 系统健康监控、多框架混合环境下的服务稳定性分析等场景。","2026-11-02 04:21:56","CREATED_QUERY"]