xrefkit-skills-batch-regression 0.4.1__tar.gz

xrefkit_skills_batch_regression-0.4.1/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: xrefkit-skills-batch-regression
+Version: 0.4.1
+Summary: XRefKit Skill Package for C# and SQL Server batch impact analysis and combination regression
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: xrefkit<0.5.0,>=0.4.0
+
+# xrefkit-skills-batch-regression
+
+XRefKit Skill Package v0.4.1 for impact analysis and combination regression of
+existing C# batches backed by SQL Server stored procedures.
+
+The package provides a discoverable XRefKit v2 Skill Package and bundles the
+repository-native Skill procedure, deterministic combination/result tools,
+source condition extraction, configuration references, and synthetic fixtures.
+Real batch and database execution still requires an isolated adapter supplied
+by the consuming project.
+
+Install:
+
+```powershell
+python -m pip install xrefkit-skills-batch-regression==0.4.1
+```
+
+The package is discovered through the `xrefkit.skill_packages` entry-point
+group and includes the deterministic tools under `skill_assets/scripts/`.

xrefkit_skills_batch_regression-0.4.1/README.md

@@ -0,0 +1,19 @@
+# xrefkit-skills-batch-regression
+
+XRefKit Skill Package v0.4.1 for impact analysis and combination regression of
+existing C# batches backed by SQL Server stored procedures.
+
+The package provides a discoverable XRefKit v2 Skill Package and bundles the
+repository-native Skill procedure, deterministic combination/result tools,
+source condition extraction, configuration references, and synthetic fixtures.
+Real batch and database execution still requires an isolated adapter supplied
+by the consuming project.
+
+Install:
+
+```powershell
+python -m pip install xrefkit-skills-batch-regression==0.4.1
+```
+
+The package is discovered through the `xrefkit.skill_packages` entry-point
+group and includes the deterministic tools under `skill_assets/scripts/`.

xrefkit_skills_batch_regression-0.4.1/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=69", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xrefkit-skills-batch-regression"
+version = "0.4.1"
+description = "XRefKit Skill Package for C# and SQL Server batch impact analysis and combination regression"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+  "xrefkit>=0.4.0,<0.5.0",
+]
+
+[project.entry-points."xrefkit.skill_packages"]
+batch_regression = "xrefkit_skills_batch_regression:package_root"
+
+[project.scripts]
+xrefkit-batch-regression = "xrefkit_skills_batch_regression.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"xrefkit_skills_batch_regression" = [
+  "package_manifest.yaml",
+  "skills/*.yaml",
+  "skill_assets/**/*",
+]

xrefkit_skills_batch_regression-0.4.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/__init__.py

@@ -0,0 +1,11 @@
+"""XRefKit Skill Package for batch impact and combination regression."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def package_root() -> Path:
+    """Return the installed package root containing package_manifest.yaml."""
+
+    return Path(__file__).parent

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/cli.py

@@ -0,0 +1,14 @@
+"""Convenience entry point for the bundled deterministic batch tool."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+def main() -> int:
+    scripts = Path(__file__).parent / "skill_assets" / "scripts"
+    sys.path.insert(0, str(scripts))
+    from batch_regression import main as run  # type: ignore
+
+    return run()

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/package_manifest.yaml

@@ -0,0 +1,42 @@
+package_id: xrefkit.skills.batch_regression
+package_type: skill_package
+version: 0.4.1
+
+requires:
+  xrefkit_core: ">=2.0.0 <3.0.0"
+
+provides:
+  skills:
+    - id: batch.impact_regression
+      xid: xid-skill-batch-impact-regression
+      path: skills/batch_impact_regression.skill.yaml
+      contract_role: base_skill
+      required_outputs:
+        - decision_table
+        - orthogonal_table
+        - regression_report
+        - evidence
+        - unknowns
+        - human_handoffs
+      required_knowledge: []
+      required_review_axes: []
+      must_not:
+        - treat_source_conditions_as_business_truth
+        - treat_baseline_results_as_business_correctness
+        - execute_against_production
+        - auto_accept_unexplained_differences
+        - claim_dynamic_sql_is_resolved_without_runtime_evidence
+
+  fragments: []
+  knowledge: []
+  review_axes: []
+  schemas: []
+  templates: []
+
+contract:
+  can_be_extended_by_local_skill: true
+  local_skill_can_weaken_contract: false
+  local_can_weaken_required_outputs: false
+  local_can_override_must_not: false
+  requires_unknown_declaration: true
+  requires_traceability: true

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/skill_assets/entry.md

@@ -0,0 +1,24 @@
+# Batch Impact Regression
+
+Analyze existing C# batches and SQL Server stored-procedure execution paths
+when a requirement changes behavior and the combination space is large.
+
+Follow the bundled 15-step workflow in `references/workflow.md`. Inspect C#
+and SQL as one execution path, keep business constraints separate from source
+conditions, and stop when dynamic dispatch, DB side effects, or expected
+differences lack evidence.
+
+Use the deterministic tools under `scripts/`:
+
+```powershell
+python scripts/batch_regression.py extract-tables <source-root> -o tables.json
+python scripts/batch_regression.py report <config.json> <old.json> <new.json> -o report.json
+```
+
+The first command creates source-backed decision-table evidence, inferred
+factors, and a strength-2 pairwise covering-table candidate. The second
+compares old/new adapter records. Neither command connects to a real database;
+use an isolated adapter conforming to `references/adapter-contract.md`.
+
+The human remains responsible for business validity, baseline correctness,
+planned differences, unexplained differences, and release disposition.

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/skill_assets/fixtures/config.json

@@ -0,0 +1,6 @@
+{
+  "combination": {"elements": [{"name":"a","values":[1,2]}, {"name":"b","values":["x","y"]}], "constraints": [{"id":"fixture-ban","kind":"forbidden","when":{"all":[{"field":"a","op":"eq","value":2},{"field":"b","op":"eq","value":"y"}]},"reason":"fixture-only constraint","evidence":["fixtures/config.json"]}]},
+  "comparison": {"key_fields":["a","b"],"fields":["status","result","updated_rows"],"ignore_fields":["execution_id"],"normalize_fields":{}},
+  "planned_differences": [{"id":"fixture-change","when":{"all":[{"field":"a","op":"eq","value":1},{"field":"b","op":"eq","value":"y"}]},"fields":["result"],"relation":"fixture-only planned difference"}],
+  "regression_set":{"max_size":10,"seed":7}
+}

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/skill_assets/fixtures/new-results.json

@@ -0,0 +1 @@
+[{"input":{"a":1,"b":"x"},"status":"success","result":10,"updated_rows":1,"execution_id":"new-1"},{"input":{"a":1,"b":"y"},"status":"success","result":11,"updated_rows":1,"execution_id":"new-2"},{"input":{"a":2,"b":"x"},"status":"success","result":99,"updated_rows":1,"execution_id":"new-3"}]

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/skill_assets/fixtures/old-results.json

@@ -0,0 +1 @@
+[{"input":{"a":1,"b":"x"},"status":"success","result":10,"updated_rows":1,"execution_id":"old-1"},{"input":{"a":1,"b":"y"},"status":"success","result":10,"updated_rows":1,"execution_id":"old-2"},{"input":{"a":2,"b":"x"},"status":"business_error","result":null,"updated_rows":0,"execution_id":"old-3"}]

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/skill_assets/references/adapter-contract.md

@@ -0,0 +1,25 @@
+<!-- xid: F4818190FD09 -->
+<a id="xid-F4818190FD09"></a>
+
+# Adapter boundary
+
+The Skill does not claim to connect to a real batch or database. An adapter
+must produce versioned JSON records with:
+
+```json
+{
+  "input": {"dimension": "value"},
+  "status": "success|business_error|system_error|not_executed",
+  "result": {"field": "value"},
+  "error": {"code": "...", "message": "..."},
+  "updated_rows": 0,
+  "path_refs": ["path-id"],
+  "evidence_refs": ["file-or-log"]
+}
+```
+
+An implementation may wrap `dotnet`, a test harness, or SQL Server tooling,
+but it must enforce the configured timeout, isolate the DB, capture exit code,
+stdout/stderr, result sets, return values, OUTPUT values, exceptions, and side
+effect checks. The deterministic scripts consume artifacts; they do not invent
+adapter output.

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/skill_assets/references/code-table-extraction.md

@@ -0,0 +1,23 @@
+<!-- xid: 8E50930676E2 -->
+<a id="xid-8E50930676E2"></a>
+
+# Code table extraction
+
+Run:
+
+```powershell
+python scripts/batch_regression.py extract-tables <source-root> -o <report.json>
+```
+
+The scanner reads `.cs` and `.sql` files and emits:
+
+- `decision_table`: each statically recognized `if`, `when`, or `case` condition with source path and line
+- `factors`: fields and literal comparison values with evidence references
+- `orthogonal_table`: deterministic strength-2 pairwise covering rows
+- `uncertainties`: expressions that were found but not resolved statically
+
+The output is evidence for review. It does not prove that a condition is an
+業務ルール, does not infer branch outcomes, and does not replace compilation,
+Roslyn analysis, SQL Server parsing, or human confirmation. Dynamic SQL,
+reflection, generated code, macros, configuration-driven rules, and complex
+multi-line expressions may remain unresolved.

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/skill_assets/references/config-schema.md

@@ -0,0 +1,25 @@
+<!-- xid: A0B8B60D3325 -->
+<a id="xid-A0B8B60D3325"></a>
+
+# Configuration schema
+
+The JSON template is intentionally declarative. Predicates use `all` or
+`any` clauses with `eq`, `neq`, `in`, `not_in`, `exists`, and `missing`.
+`forbidden` excludes a candidate; `business_invalid`, `upstream_absent`, and
+`uncertain` classify it without pretending to prove the business rule.
+
+Top-level fields:
+
+- `system`: `solution`, `project`, `command`, `test_db`, `old_version`, `new_version`, `timeout_seconds`, `parallelism`, `side_effect_check`
+- `combination.elements`: ordered `{name, values}` dimensions
+- `combination.constraints`: `{id, kind, when, reason, evidence}`
+- `comparison`: `key_fields`, `fields`, `ignore_fields`, `normalize_fields`
+- `planned_differences`: `{id, when, fields, relation, evidence}`
+- `paths`: `{id, description, csharp, stored_procedures, child_stored_procedures, dynamic_sql, dynamic_sp_name}` for trace links
+- `regression_set`: `max_size`, `seed`
+
+Source-table extraction is invoked separately with the source root; it does not
+require a comparison result file or a database adapter.
+
+Constraint and expectation predicates are data, not Python or SQL. No example
+in this Skill claims an actual business rule; template values are placeholders.

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/skill_assets/references/config.template.json

@@ -0,0 +1,31 @@
+{
+  "system": {
+    "solution": "path/to/app.sln",
+    "project": "path/to/batch.csproj",
+    "command": "dotnet run --project path/to/batch.csproj -- ...",
+    "test_db": "isolated-test-db-connection-placeholder",
+    "old_version": "old-build-or-commit",
+    "new_version": "new-build-or-commit",
+    "timeout_seconds": 60,
+    "parallelism": 1,
+    "side_effect_check": "before-after row counts and changed keys; human-approved rollback/restore"
+  },
+  "combination": {
+    "elements": [
+      {"name": "dimension_a", "values": ["value_a1", "value_a2"]},
+      {"name": "dimension_b", "values": ["value_b1", "value_b2"]}
+    ],
+    "constraints": [
+      {"id": "constraint-placeholder", "kind": "forbidden", "when": {"all": [{"field": "dimension_a", "op": "eq", "value": "value_a1"}, {"field": "dimension_b", "op": "eq", "value": "value_b2"}]}, "reason": "REPLACE_WITH_EVIDENCED_RULE", "evidence": ["human-approved-source"]}
+    ]
+  },
+  "comparison": {
+    "key_fields": ["dimension_a", "dimension_b"],
+    "fields": ["status", "result", "updated_rows"],
+    "ignore_fields": ["execution_id", "started_at", "finished_at"],
+    "normalize_fields": {"started_at": "datetime", "finished_at": "datetime"}
+  },
+  "planned_differences": [],
+  "paths": [],
+  "regression_set": {"max_size": 20, "seed": 7}
+}

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/skill_assets/references/csharp-sql-analysis.md

@@ -0,0 +1,17 @@
+<!-- xid: 9C03927FF35B -->
+<a id="xid-9C03927FF35B"></a>
+
+# C# and SQL Server analysis checklist
+
+Analyze one execution path across both layers. Record evidence locations for:
+
+- C# schedule/CLI entry, command construction, SP name resolution, parameter names/types/size/precision/scale, NULL/empty/default/date/decimal conversion, timeout, retries, cancellation, result-set mapping, return value, OUTPUT parameters, and exceptions.
+- SP definitions and child SPs, functions, views, tables, temp tables, table variables, dynamic SQL, dynamic object names, validation/calculation/update branches, row counts, transaction boundaries, isolation, locks, commits/rollbacks, triggers, and error propagation.
+- Cross-boundary type, precision/scale, rounding, collation, date/time-zone, NULL, empty-string, default-value, and encoding behavior.
+
+Do not conclude from C# alone or SQL alone. If dynamic SQL or dynamic SP
+resolution cannot be closed statically, record the unresolved target and the
+affected candidate count as `uncertain` until runtime evidence closes it.
+Never run a write-capable batch against production. Prefer a cloned/snapshot
+DB, isolated schema, disposable database, or transaction rollback, and prove
+the side-effect check with before/after row counts and changed keys.

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/skill_assets/references/fixture-notes.md

@@ -0,0 +1,8 @@
+<!-- xid: B1EDF6CFC6BE -->
+<a id="xid-B1EDF6CFC6BE"></a>
+
+# Fixture boundary
+
+The files under `fixtures/` contain synthetic values only. They demonstrate
+the adapter record shape and classification mechanics; they are not business
+constraints, production results, or evidence about any real batch.

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/skill_assets/references/workflow.md

@@ -0,0 +1,44 @@
+<!-- xid: 427525B4935A -->
+<a id="xid-427525B4935A"></a>
+
+# Workflow and decision rules
+
+## 15-step sequence
+
+1. Confirm system boundary, executable command, versions, isolated DB, and adapter.
+2. Locate C# entry points and every SP invocation and parameter mapping.
+3. Trace child SPs, functions, views, tables, temp objects, table variables, dynamic SQL, transactions, outputs, result sets, and exceptions.
+4. Extract combination dimensions and values from evidence; mark missing values unknown.
+5. Record business, technical, and upstream constraints in separate ledgers.
+6. Compute Cartesian candidate count and post-constraint count deterministically.
+7. Prove safe execution with a small input and verify DB side effects.
+8. Decide full-run feasibility from measured duration, timeout, parallelism, and side effects.
+9. Capture the old version as observed baseline, never as business truth.
+10. Define the new requirement predicate and allowed differences with evidence and owner.
+11. Run old and new on identical serialized inputs through an isolated adapter.
+12. Normalize and classify each result; retain traceability for every difference.
+13. Select a deterministic daily reduced regression set covering dimensions, constraints, paths, and difference classes.
+14. Generate a release-time full-run procedure with rollback/restore and stop gates.
+15. Escalate unresolved decisions; do not close while material unknowns remain unowned.
+
+## Classification precedence
+
+`system_error` > `uncertain` > `business_invalid` > `upstream_absent` >
+result comparison. An explicitly configured `business_invalid` or
+`upstream_absent` predicate is evidence for classification, not a substitute
+for human approval. A missing predicate or unresolved dynamic path is
+`uncertain`, not valid.
+
+## Result comparison
+
+Compare configured fields after removing or normalizing only configured
+non-deterministic fields. `planned_difference` requires a matching expected
+difference rule. Any other changed value is `unexplained_difference`.
+Unchanged successful outcomes are `baseline_match`. Missing execution records
+are `not_executed`.
+
+## Human decisions
+
+Present the candidate input, counts, evidence, and impact of each option for:
+business validity, baseline defects, expected differences, upstream absence,
+and release disposition. Do not fill these decisions by inference.

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/skill_assets/scripts/batch_regression.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""Deterministic combination and old/new batch-result analysis.
+
+This module deliberately has no database or process adapter. Adapters emit the
+JSON record contract in references/adapter-contract.md; this tool consumes it.
+"""
+from __future__ import annotations
+import argparse, csv, hashlib, itertools, json, random, sys
+from datetime import datetime
+from pathlib import Path
+from code_tables import extract_source_tables, pairwise_table
+
+STATUSES = {"success", "business_error", "system_error", "not_executed"}
+
+def predicate(value, spec):
+    if not spec: return False
+    clauses = spec.get("all", spec.get("any", []))
+    matched = [clause(value, c) for c in clauses]
+    return all(matched) if "all" in spec else any(matched)
+
+def clause(row, c):
+    field, op, expected = c["field"], c["op"], c.get("value")
+    present = field in row and row[field] is not None
+    actual = row.get(field)
+    if op == "eq": return actual == expected
+    if op == "neq": return actual != expected
+    if op == "in": return actual in expected if isinstance(expected, (list, tuple, set)) else False
+    if op == "not_in": return actual not in expected if isinstance(expected, (list, tuple, set)) else False
+    if op == "exists": return present
+    if op == "missing": return not present
+    return False
+
+def generate_candidates(config):
+    elements = config["combination"]["elements"]
+    names = [e["name"] for e in elements]
+    candidates = [dict(zip(names, values)) for values in itertools.product(*(e["values"] for e in elements))]
+    all_count = len(candidates)
+    kept, classifications = [], []
+    for row in candidates:
+        excluded = None
+        for c in config["combination"].get("constraints", []):
+            kind = c["kind"]
+            matched = predicate(row, c.get("when"))
+            missing_required = kind in ("required", "required_if") and matched and not row.get(c.get("field"))
+            if matched and (kind in ("forbidden", "business_invalid", "upstream_absent", "uncertain") or missing_required):
+                excluded = c
+                break
+        if excluded:
+            kind = excluded["kind"]
+            classification = {"forbidden": "business_invalid", "business_invalid": "business_invalid", "upstream_absent": "upstream_absent", "uncertain": "uncertain"}.get(kind, "business_invalid")
+            classifications.append({"input": row, "classification": classification, "constraint": excluded})
+        else:
+            kept.append(row)
+            classifications.append({"input": row, "classification": "candidate"})
+    return {"all_candidate_count": all_count, "post_constraint_count": len(kept), "candidates": kept, "classifications": classifications}
+
+def analyze_paths(paths):
+    """Summarize static execution-path evidence without pretending to resolve dynamic dispatch."""
+    result = {"path_count": len(paths), "dual_layer_paths": 0, "child_sp_paths": 0, "dynamic_unknowns": []}
+    for path in paths:
+        if path.get("csharp") and path.get("stored_procedures"): result["dual_layer_paths"] += 1
+        if path.get("child_stored_procedures"): result["child_sp_paths"] += 1
+        if path.get("dynamic_sql") or path.get("dynamic_sp_name"):
+            result["dynamic_unknowns"].append({"path_id": path.get("id"), "reason": "dynamic SQL or stored-procedure target requires runtime evidence"})
+    return result
+
+def normalize(record, config):
+    record = json.loads(json.dumps(record, ensure_ascii=False))
+    for field in config.get("comparison", {}).get("ignore_fields", []): record.pop(field, None)
+    for field, kind in config.get("comparison", {}).get("normalize_fields", {}).items():
+        if field not in record: continue
+        if kind == "datetime":
+            try: record[field] = datetime.fromisoformat(str(record[field]).replace("Z", "+00:00")).isoformat()
+            except ValueError: record[field] = "<invalid-datetime>"
+        elif kind == "number":
+            try: record[field] = float(record[field])
+            except (TypeError, ValueError): record[field] = "<invalid-number>"
+    return record
+
+def compare(old_records, new_records, config):
+    key = lambda r: tuple(r.get("input", {}).get(k) for k in config["comparison"]["key_fields"])
+    old, new = {key(r): r for r in old_records}, {key(r): r for r in new_records}
+    expected = config.get("planned_differences", [])
+    rows = []
+    for k in sorted(set(old) | set(new), key=str):
+        o, n = old.get(k), new.get(k)
+        if not o or not n: cls = "not_executed"
+        elif n.get("status") == "system_error" or o.get("status") == "system_error": cls = "system_error"
+        elif n.get("status") == "not_executed": cls = "not_executed"
+        elif n.get("status") == "business_error" and o.get("status") != "business_error": cls = "business_invalid"
+        elif n.get("status") not in STATUSES or o.get("status") not in STATUSES: cls = "uncertain"
+        else:
+            on, nn = normalize(o, config), normalize(n, config)
+            fields = config["comparison"].get("fields", [])
+            changed = [f for f in fields if on.get(f) != nn.get(f)]
+            if not changed: cls = "baseline_match"
+            else:
+                hit = next((p for p in expected if predicate(n.get("input", {}), p.get("when")) and set(changed).issubset(set(p.get("fields", [])))), None)
+                cls = "planned_difference" if hit else "unexplained_difference"
+        rows.append({"input": (n or o).get("input", {}), "old": o, "new": n, "classification": cls,
+                     "path_refs": sorted(set((o or {}).get("path_refs", []) + (n or {}).get("path_refs", []))),
+                     "planned_relation": next((p.get("relation") for p in expected if predicate((n or o).get("input", {}), p.get("when"))), None)})
+    return rows
+
+def summarize(candidate_report, comparisons, config):
+    counts = {k: 0 for k in ["baseline_match", "business_invalid", "system_error", "planned_difference", "unexplained_difference", "uncertain", "not_executed", "upstream_absent"]}
+    for row in candidate_report["classifications"]:
+        if row["classification"] == "business_invalid": counts["business_invalid"] += 1
+    for row in comparisons: counts[row["classification"]] = counts.get(row["classification"], 0) + 1
+    old_records = [row["old"] for row in comparisons if row.get("old")]
+    new_records = [row["new"] for row in comparisons if row.get("new")]
+    paths = {}
+    for row in comparisons:
+        for path in row.get("path_refs", []) or ["unattributed"]: paths[path] = paths.get(path, 0) + 1
+    return {**counts, "all_candidate_count": candidate_report["all_candidate_count"], "post_constraint_count": candidate_report["post_constraint_count"],
+            "current_normal_count": sum(r.get("status") == "success" for r in old_records),
+            "business_error_count": sum(r.get("status") == "business_error" for r in old_records),
+            "new_system_error_count": sum(r.get("status") == "system_error" for r in new_records),
+            "unexecuted_count": counts.get("not_executed", 0),
+            "processed_count": len(comparisons), "path_counts": paths, "representative_regression_set_count": len(select_regression_set(comparisons, config)),
+            "analysis": analyze_paths(config.get("paths", [])),
+            "human_judgments_required": ["business validity", "baseline defects", "planned differences", "unexplained differences", "release disposition"]}
+
+def select_regression_set(rows, config):
+    limit, seed = config.get("regression_set", {}).get("max_size", 100), config.get("regression_set", {}).get("seed", 0)
+    by_class = {}
+    for row in rows: by_class.setdefault(row["classification"], []).append(row)
+    selected = []
+    for cls in sorted(by_class): selected.append(sorted(by_class[cls], key=lambda r: json.dumps(r["input"], sort_keys=True))[0])
+    rest = [r for r in rows if r not in selected]; random.Random(seed).shuffle(rest)
+    return (selected + rest)[:limit]
+
+def load(path): return json.loads(Path(path).read_text(encoding="utf-8"))
+def main(argv=None):
+    p = argparse.ArgumentParser(); sub = p.add_subparsers(dest="cmd", required=True)
+    g = sub.add_parser("generate"); g.add_argument("config"); g.add_argument("-o", "--output", required=True)
+    c = sub.add_parser("compare"); c.add_argument("config"); c.add_argument("old"); c.add_argument("new"); c.add_argument("-o", "--output", required=True)
+    r = sub.add_parser("report"); r.add_argument("config"); r.add_argument("old"); r.add_argument("new"); r.add_argument("-o", "--output", required=True)
+    t = sub.add_parser("extract-tables"); t.add_argument("root"); t.add_argument("-o", "--output", required=True)
+    args = p.parse_args(argv)
+    if args.cmd == "extract-tables":
+        out = extract_source_tables(args.root)
+        out["orthogonal_table"] = pairwise_table(out["factors"])
+    else:
+        config = load(args.config); candidates = generate_candidates(config)
+        if args.cmd == "generate": out = candidates
+        else:
+            comparisons = compare(load(args.old), load(args.new), config)
+            if args.cmd == "compare": out = comparisons
+            else: out = {"summary": summarize(candidates, comparisons, config), "comparisons": comparisons, "regression_set": select_regression_set(comparisons, config)}
+    Path(args.output).write_text(json.dumps(out, ensure_ascii=False, indent=2), encoding="utf-8"); return 0
+if __name__ == "__main__": sys.exit(main())

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/skill_assets/scripts/code_tables.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""Conservative, evidence-preserving extraction of decision and pairwise tables.
+
+This is a syntax scanner, not a C# or T-SQL compiler. Unresolved expressions
+remain explicit in ``uncertainties`` and must not be promoted to business rules.
+"""
+from __future__ import annotations
+import itertools, re
+from pathlib import Path
+
+CONDITION_RE = re.compile(r"\b(if|when|case)\b(?P<expr>[^\r\n]*)", re.I)
+COMPARISON_RE = re.compile(r"(?P<field>[\[\]A-Za-z_][\w.\[\]]*)\s*(?P<op>==|!=|>=|<=|>|<|=|\bIN\b|\bIS\b)\s*(?P<value>\([^\)]*\)|[^,;\s\)]+)", re.I)
+STRING_RE = re.compile(r"'(?:''|[^'])*'|\"(?:\\.|[^\"])*\"")
+IDENTIFIER_RE = re.compile(r"^[\[\]A-Za-z_][\w.\[\]]*$")
+KEYWORDS = {"if", "when", "case", "then", "else", "and", "or", "not", "is", "null", "true", "false"}
+
+def _clean(value):
+    value = value.strip().strip("[]")
+    return value
+
+def _literal_values(value):
+    value = value.strip()
+    if value.startswith("(") and value.endswith(")"):
+        parts = value[1:-1].split(",")
+        return [_clean(p).strip("'\"") for p in parts if p.strip()]
+    if STRING_RE.fullmatch(value): return [value[1:-1].replace("''", "'").replace('\\"', '"')]
+    if re.fullmatch(r"-?\d+(?:\.\d+)?", value): return [value]
+    if value.upper() in {"NULL", "TRUE", "FALSE"}: return [value.upper()]
+    return []
+
+def _language(path): return "csharp" if path.suffix.lower() == ".cs" else "sql"
+
+def extract_source_tables(root):
+    root = Path(root)
+    rows, factors, uncertainties, files = [], {}, [], []
+    paths = sorted(p for p in root.rglob("*") if p.is_file() and p.suffix.lower() in {".cs", ".sql"})
+    for path in paths:
+        rel = str(path.relative_to(root)).replace("\\", "/")
+        files.append(rel)
+        for line_no, line in enumerate(path.read_text(encoding="utf-8", errors="replace").splitlines(), 1):
+            for match in CONDITION_RE.finditer(line):
+                expr = match.group("expr").strip()
+                expr = re.sub(r"^\(?\s*(?:when|case)\b", "", expr, flags=re.I).strip()
+                expr = re.split(r"\bthen\b", expr, maxsplit=1, flags=re.I)[0].strip()
+                expr = expr.rstrip("{").strip().rstrip(")").strip()
+                comparisons = []
+                for comp in COMPARISON_RE.finditer(expr):
+                    field, op, raw = _clean(comp.group("field")), comp.group("op").upper(), comp.group("value")
+                    if field.lower() in KEYWORDS: continue
+                    values = _literal_values(raw)
+                    if not values:
+                        uncertainties.append({"source": f"{rel}:{line_no}", "expression": expr, "reason": "comparison value or expression is not statically literal"})
+                        values = ["<unknown>"]
+                    comparisons.append({"field": field, "operator": op, "values": values})
+                    factors.setdefault(field, {"values": set(), "evidence": []})["values"].update(values)
+                    factors[field]["evidence"].append(f"{rel}:{line_no}")
+                if comparisons:
+                    rows.append({"id": f"DT-{len(rows)+1:04d}", "source": f"{rel}:{line_no}", "language": _language(path), "construct": match.group(1).lower(), "condition": expr, "conditions": comparisons, "outcome": "<human-confirmation-required>"})
+                elif expr and not IDENTIFIER_RE.fullmatch(expr):
+                    uncertainties.append({"source": f"{rel}:{line_no}", "expression": expr, "reason": "condition found but no deterministic comparison extracted"})
+    factor_list = [{"name": name, "values": sorted(data["values"], key=str), "evidence": sorted(set(data["evidence"]))} for name, data in sorted(factors.items())]
+    return {"source_root": str(root), "files": files, "factors": factor_list, "decision_table": rows, "uncertainties": uncertainties}
+
+def pairwise_table(factors):
+    """Create a deterministic strength-2 covering table from extracted factors."""
+    if not factors: return {"strength": 2, "rows": [], "uncovered_pairs": []}
+    names, domains = [f["name"] for f in factors], [f["values"] or ["<unknown>"] for f in factors]
+    if len(names) == 1: return {"strength": 2, "rows": [{names[0]: v} for v in domains[0]], "uncovered_pairs": []}
+    required = {(i, j, a, b) for i in range(len(names)) for j in range(i+1, len(names)) for a in domains[i] for b in domains[j]}
+    candidates = [dict(zip(names, values)) for values in itertools.product(*domains)]
+    selected = []
+    while required:
+        best = max(candidates, key=lambda row: sum((i, j, row[names[i]], row[names[j]]) in required for i in range(len(names)) for j in range(i+1, len(names))))
+        selected.append(best)
+        required -= {(i, j, best[names[i]], best[names[j]]) for i in range(len(names)) for j in range(i+1, len(names))}
+        candidates.remove(best)
+    return {"strength": 2, "rows": selected, "uncovered_pairs": sorted([list(x) for x in required], key=str)}

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression/skills/batch_impact_regression.skill.yaml

@@ -0,0 +1,44 @@
+skill_id: batch.impact_regression
+xid: xid-skill-batch-impact-regression
+role: base_skill_contract
+
+entry:
+  xid: xid-entry-batch-impact-regression
+  path: skill_assets/entry.md
+  load_policy: required_inline
+
+required_fragments:
+  - id: batch_regression_workflow
+    xid: xid-fragment-batch-regression-workflow
+    path: skill_assets/references/workflow.md
+    load_policy: required_inline
+  - id: batch_regression_adapter_boundary
+    xid: xid-fragment-batch-regression-adapter-boundary
+    path: skill_assets/references/adapter-contract.md
+    load_policy: required_inline
+
+branches: []
+
+required_outputs:
+  - decision_table
+  - orthogonal_table
+  - regression_report
+  - evidence
+  - unknowns
+  - human_handoffs
+
+required_knowledge: []
+review_axes: []
+schemas: []
+
+must_not:
+  - treat_source_conditions_as_business_truth
+  - treat_baseline_results_as_business_correctness
+  - execute_against_production
+  - auto_accept_unexplained_differences
+  - claim_dynamic_sql_is_resolved_without_runtime_evidence
+
+extension_policy:
+  can_be_extended_by_local_skill: true
+  local_can_weaken_required_outputs: false
+  local_can_override_must_not: false

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression.egg-info/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: xrefkit-skills-batch-regression
+Version: 0.4.1
+Summary: XRefKit Skill Package for C# and SQL Server batch impact analysis and combination regression
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: xrefkit<0.5.0,>=0.4.0
+
+# xrefkit-skills-batch-regression
+
+XRefKit Skill Package v0.4.1 for impact analysis and combination regression of
+existing C# batches backed by SQL Server stored procedures.
+
+The package provides a discoverable XRefKit v2 Skill Package and bundles the
+repository-native Skill procedure, deterministic combination/result tools,
+source condition extraction, configuration references, and synthetic fixtures.
+Real batch and database execution still requires an isolated adapter supplied
+by the consuming project.
+
+Install:
+
+```powershell
+python -m pip install xrefkit-skills-batch-regression==0.4.1
+```
+
+The package is discovered through the `xrefkit.skill_packages` entry-point
+group and includes the deterministic tools under `skill_assets/scripts/`.

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression.egg-info/SOURCES.txt

@@ -0,0 +1,25 @@
+README.md
+pyproject.toml
+src/xrefkit_skills_batch_regression/__init__.py
+src/xrefkit_skills_batch_regression/cli.py
+src/xrefkit_skills_batch_regression/package_manifest.yaml
+src/xrefkit_skills_batch_regression.egg-info/PKG-INFO
+src/xrefkit_skills_batch_regression.egg-info/SOURCES.txt
+src/xrefkit_skills_batch_regression.egg-info/dependency_links.txt
+src/xrefkit_skills_batch_regression.egg-info/entry_points.txt
+src/xrefkit_skills_batch_regression.egg-info/requires.txt
+src/xrefkit_skills_batch_regression.egg-info/top_level.txt
+src/xrefkit_skills_batch_regression/skill_assets/entry.md
+src/xrefkit_skills_batch_regression/skill_assets/fixtures/config.json
+src/xrefkit_skills_batch_regression/skill_assets/fixtures/new-results.json
+src/xrefkit_skills_batch_regression/skill_assets/fixtures/old-results.json
+src/xrefkit_skills_batch_regression/skill_assets/references/adapter-contract.md
+src/xrefkit_skills_batch_regression/skill_assets/references/code-table-extraction.md
+src/xrefkit_skills_batch_regression/skill_assets/references/config-schema.md
+src/xrefkit_skills_batch_regression/skill_assets/references/config.template.json
+src/xrefkit_skills_batch_regression/skill_assets/references/csharp-sql-analysis.md
+src/xrefkit_skills_batch_regression/skill_assets/references/fixture-notes.md
+src/xrefkit_skills_batch_regression/skill_assets/references/workflow.md
+src/xrefkit_skills_batch_regression/skill_assets/scripts/batch_regression.py
+src/xrefkit_skills_batch_regression/skill_assets/scripts/code_tables.py
+src/xrefkit_skills_batch_regression/skills/batch_impact_regression.skill.yaml

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression.egg-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+xrefkit-batch-regression = xrefkit_skills_batch_regression.cli:main
+
+[xrefkit.skill_packages]
+batch_regression = xrefkit_skills_batch_regression:package_root

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression.egg-info/requires.txt

@@ -0,0 +1 @@
+xrefkit<0.5.0,>=0.4.0

xrefkit_skills_batch_regression-0.4.1/src/xrefkit_skills_batch_regression.egg-info/top_level.txt

@@ -0,0 +1 @@
+xrefkit_skills_batch_regression