specfuse-loop 0.28.1__tar.gz → 0.28.2__tar.gz

{specfuse_loop-0.28.1/specfuse_loop.egg-info → specfuse_loop-0.28.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specfuse-loop
-Version: 0.28.1
+Version: 0.28.2
 Summary: Local-first executor for the Specfuse Plan + Work Unit gate-cycle methodology.
 Author: Specfuse contributors
 License: Apache-2.0

{specfuse_loop-0.28.1 → specfuse_loop-0.28.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specfuse-loop"
-version = "0.28.1"
+version = "0.28.2"
 description = "Local-first executor for the Specfuse Plan + Work Unit gate-cycle methodology."
 readme = "README.md"
 requires-python = ">=3.10"

specfuse_loop-0.28.2/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.28.2

{specfuse_loop-0.28.1 → specfuse_loop-0.28.2}/specfuse/loop/loop.py

@@ -127,7 +127,7 @@ SPECFUSE_DIR = Path(".specfuse")
 REPO_ROOT = SPECFUSE_DIR.parent
 FEATURES_DIR = SPECFUSE_DIR / "features"
 VERIFICATION_PATH = SPECFUSE_DIR / "verification.yml"
-DRIVER_VERSION = "0.28.1"
+DRIVER_VERSION = "0.28.2"
 # Oldest scaffold layout this driver can drive. init.sh stamps the scaffold's own
 # version into `.specfuse/VERSION`; check_scaffold_version() fails loud at startup if
 # the consumer's scaffold is older than this, pointing at `specfuse upgrade`. Bump

{specfuse_loop-0.28.1 → specfuse_loop-0.28.2}/specfuse/monitor/cli.py

@@ -457,6 +457,10 @@ def run_cycle(
     out = out if out is not None else sys.stdout
     now = now if now is not None else datetime.now(timezone.utc)
     gh_runner = gh_runner if gh_runner is not None else _default_runner
+    # Fingerprints already handed to `record_finding` this cycle (#3486): the
+    # `gh issue list` lookup can lag an issue created moments earlier, so a
+    # repeated fingerprint must not reach it twice.
+    filed_fingerprints: set = set()
 
     environments = config.get("environments") or {}
     components = config.get("components") or []
@@ -540,9 +544,13 @@ def run_cycle(
                 for artifact in findings:
                     summary.append(f"  would file: {_describe(artifact)}")
             else:
-                created = updated = throttled = 0
+                created = updated = throttled = repeats = 0
                 for artifact in findings:
                     fingerprint = fingerprint_artifact(artifact)
+                    if fingerprint in filed_fingerprints:
+                        repeats += 1
+                        continue
+                    filed_fingerprints.add(fingerprint)
                     recorder = _CallRecorder(gh_runner)
                     record_finding(fingerprint, artifact, repo, runner=recorder, now=now.timestamp())
                     outcome = _classify(recorder)
@@ -552,10 +560,13 @@ def run_cycle(
                         updated += 1
                     else:
                         throttled += 1
-                summary.append(
+                line = (
                     f"{env_name}/{component_name}: {len(findings)} finding(s) — "
                     f"created {created}, updated {updated}, throttled {throttled}"
                 )
+                if repeats:
+                    line += f", {repeats} repeat(s) of an already-filed fingerprint"
+                summary.append(line)
 
             for skip in skipped:
                 summary.append(

{specfuse_loop-0.28.1 → specfuse_loop-0.28.2}/specfuse/monitor/diagnose_cli.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import re
 import sys
 from typing import Any
 
@@ -37,6 +38,19 @@ class AnalysisParseError(ValueError):
     """
 
 
+#: One markdown code fence around the whole result, optionally tagged `json`.
+#: Headless sessions asked for "exactly one JSON object" still fence it often
+#: (#3489); anything outside the fence stays a parse error.
+_FENCE_RE = re.compile(r"\A\s*```(?:json)?[ \t]*\n(?P<body>.*?)\n```\s*\Z", re.DOTALL)
+
+
+def _strip_fence(raw: str) -> str:
+    match = _FENCE_RE.match(raw)
+    if match is None or "```" in match.group("body"):
+        return raw
+    return match.group("body")
+
+
 def parse_analysis(raw: str) -> Diagnosis:
     """Parse an analysis-step result (JSON text) into a `Diagnosis`.
 
@@ -45,7 +59,7 @@ def parse_analysis(raw: str) -> Diagnosis:
     required field, or a `fix_scope` outside `FIX_SCOPES`.
     """
     try:
-        data: Any = json.loads(raw)
+        data: Any = json.loads(_strip_fence(raw))
     except json.JSONDecodeError as exc:
         raise AnalysisParseError(f"analysis result is not valid JSON: {exc}") from exc
 

{specfuse_loop-0.28.1 → specfuse_loop-0.28.2/specfuse_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specfuse-loop
-Version: 0.28.1
+Version: 0.28.2
 Summary: Local-first executor for the Specfuse Plan + Work Unit gate-cycle methodology.
 Author: Specfuse contributors
 License: Apache-2.0

{specfuse_loop-0.28.1 → specfuse_loop-0.28.2}/specfuse_loop.egg-info/SOURCES.txt

@@ -295,6 +295,7 @@ tests/test_derive_monitoring_discovery.py
 tests/test_derive_monitoring_skill_registration.py
 tests/test_design_for_diagnosis_rule.py
 tests/test_deterministic_refusal_repeat.py
+tests/test_diagnose_fenced_analysis.py
 tests/test_diagnose_headless.py
 tests/test_diagnose_issue_skill.py
 tests/test_diagnosis.py
@@ -487,6 +488,7 @@ tests/test_monitor_check_isolation.py
 tests/test_monitor_cli.py
 tests/test_monitor_durations.py
 tests/test_monitor_issue_lifecycle.py
+tests/test_monitor_one_issue_per_fingerprint.py
 tests/test_monitor_runner_surfaces.py
 tests/test_monitoring_bootstrap_artifacts.py
 tests/test_monitoring_cron_dialect.py

specfuse_loop-0.28.2/tests/test_diagnose_fenced_analysis.py

@@ -0,0 +1,69 @@
+# Copyright 2026 Specfuse Contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+"""#3489: a headless analysis session often wraps its one JSON object in a
+markdown code fence. `parse_analysis` must read a single surrounding fence as
+the object it holds, and stay strict about everything else.
+"""
+
+from __future__ import annotations
+
+import json
+import unittest
+
+from specfuse.monitor.diagnose_cli import AnalysisParseError, parse_analysis
+
+_PAYLOAD = {
+    "root_cause": "The weekly job last ran before heartbeat emission shipped.",
+    "evidence": "AppRequests show successful runs; no ScheduleHeartbeat before 2026-10-14.",
+    "candidate_fix": "None in the component; wait for the next firing.",
+    "confidence": 0.7,
+    "fix_scope": "external",
+}
+_JSON = json.dumps(_PAYLOAD, indent=2)
+
+
+class TestFencedAnalysisParses(unittest.TestCase):
+    def _assert_parses(self, raw):
+        diagnosis = parse_analysis(raw)
+        self.assertEqual(diagnosis.fix_scope, "external")
+        self.assertEqual(diagnosis.confidence, 0.7)
+        self.assertEqual(diagnosis.root_cause, _PAYLOAD["root_cause"])
+
+    def test_json_fence_parses(self):
+        self._assert_parses(f"```json\n{_JSON}\n```")
+
+    def test_bare_fence_parses(self):
+        self._assert_parses(f"```\n{_JSON}\n```")
+
+    def test_fence_with_surrounding_whitespace_parses(self):
+        self._assert_parses(f"\n\n```json\n{_JSON}\n```\n")
+
+    def test_unfenced_still_parses(self):
+        self._assert_parses(_JSON)
+
+
+class TestStillStrict(unittest.TestCase):
+    def test_prose_before_fence_is_rejected(self):
+        with self.assertRaises(AnalysisParseError):
+            parse_analysis(f"Here is the diagnosis:\n```json\n{_JSON}\n```")
+
+    def test_prose_after_fence_is_rejected(self):
+        with self.assertRaises(AnalysisParseError):
+            parse_analysis(f"```json\n{_JSON}\n```\nLet me know if you need more.")
+
+    def test_two_fenced_objects_are_rejected(self):
+        with self.assertRaises(AnalysisParseError):
+            parse_analysis(f"```json\n{_JSON}\n```\n```json\n{_JSON}\n```")
+
+    def test_unterminated_fence_is_rejected(self):
+        with self.assertRaises(AnalysisParseError):
+            parse_analysis(f"```json\n{_JSON}\n")
+
+    def test_fenced_payload_missing_field_is_rejected(self):
+        partial = {k: v for k, v in _PAYLOAD.items() if k != "fix_scope"}
+        with self.assertRaises(AnalysisParseError):
+            parse_analysis(f"```json\n{json.dumps(partial)}\n```")
+
+
+if __name__ == "__main__":
+    unittest.main()

specfuse_loop-0.28.2/tests/test_monitor_one_issue_per_fingerprint.py

@@ -0,0 +1,108 @@
+# Copyright 2026 Specfuse Contributors
+# Licensed under the Apache License, Version 2.0. See LICENSE.
+"""#3486: a cycle that yields one fingerprint several times must file one
+issue, not one per row. The issue listing `record_finding` looks issues up
+through can lag behind an issue this same cycle just created, so the cycle
+itself must not hand the same fingerprint to `record_finding` twice.
+"""
+
+from __future__ import annotations
+
+import io
+import tempfile
+import unittest
+from datetime import datetime, timezone
+from pathlib import Path
+from types import SimpleNamespace
+
+import specfuse.monitor.cli as cli
+
+_NOW = datetime(2026, 10, 17, 1, 0, 0, tzinfo=timezone.utc)
+_REPO = "acme-widget/repo"
+
+
+def _config():
+    return {
+        "environments": {
+            "production": {
+                "telemetry": {"provider": "azure_app_insights", "credentials": {"api_key": "ACME_API_KEY"}},
+            },
+        },
+        "components": [{
+            "name": "web-api",
+            "type": "api",
+            "runner": "local",
+            "diagnose": "manual",
+            "autofix": "off",
+            "checks": [{"type": "error-logs"}],
+        }],
+    }
+
+
+class _Transport:
+    def __init__(self, rows):
+        self._rows = rows
+
+    def run_query(self, query):
+        return list(self._rows)
+
+
+_CANCELLED = {"type": "System.Threading.Tasks.TaskCanceledException", "outerMessage": "A task was canceled."}
+_NULL_REF = {"type": "System.NullReferenceException", "outerMessage": "Object reference not set."}
+
+
+class _LaggingGh:
+    """`gh issue list` never shows an issue created in this cycle, as GitHub's
+    listing did on the run that filed #1014 and #1015 two seconds apart."""
+
+    def __init__(self):
+        self.created = 0
+
+    def __call__(self, args, check=True):
+        if args[:3] == ["gh", "issue", "list"]:
+            return SimpleNamespace(returncode=0, stdout="[]", stderr="")
+        if args[:3] == ["gh", "issue", "create"]:
+            self.created += 1
+            return SimpleNamespace(
+                returncode=0, stdout=f"https://github.com/{_REPO}/issues/{self.created}\n", stderr=""
+            )
+        raise AssertionError(f"unexpected gh call: {args}")
+
+
+class TestOneIssuePerFingerprintPerCycle(unittest.TestCase):
+    def setUp(self):
+        self._tmpdir = tempfile.TemporaryDirectory()
+        self.addCleanup(self._tmpdir.cleanup)
+
+    def _run(self, rows):
+        gh = _LaggingGh()
+        out = io.StringIO()
+        code = cli.run_cycle(
+            _config(),
+            dry_run=False,
+            repo=_REPO,
+            transport_resolver=lambda module, check_type, binding: _Transport(rows),
+            gh_runner=gh,
+            now=_NOW,
+            watermark_dir=Path(self._tmpdir.name),
+            out=out,
+        )
+        return code, out.getvalue(), gh
+
+    def test_repeated_rows_file_one_issue(self):
+        code, output, gh = self._run([_CANCELLED, _CANCELLED, _CANCELLED])
+        self.assertEqual(code, 0)
+        self.assertEqual(gh.created, 1, output)
+        self.assertIn("created 1", output)
+
+    def test_summary_names_the_merged_repeats(self):
+        _, output, _ = self._run([_CANCELLED, _CANCELLED, _CANCELLED])
+        self.assertIn("2 repeat(s) of an already-filed fingerprint", output)
+
+    def test_distinct_fingerprints_still_file_separately(self):
+        _, output, gh = self._run([_CANCELLED, _NULL_REF, _CANCELLED])
+        self.assertEqual(gh.created, 2, output)
+
+
+if __name__ == "__main__":
+    unittest.main()

specfuse_loop-0.28.1/specfuse/loop/data/VERSION

@@ -1 +0,0 @@
-0.28.1