code2llm 0.5.183__tar.gz → 0.5.185__tar.gz

{code2llm-0.5.183/code2llm.egg-info → code2llm-0.5.185}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.183
+Version: 0.5.185
 Summary: High-performance Python code flow analysis with optimized TOON format - CFG, DFG, call graphs, and intelligent code queries
 Home-page: https://github.com/wronai/stts
 Author: Tom Sapletta
@@ -101,6 +101,7 @@ When you run `code2llm ./ -f all`, the following files are created:
 |------|--------|---------|--------------|
 | `evolution.toon.yaml` | **YAML** | **📋 Refactoring queue** - Prioritized improvements | 0 refactoring actions needed |
 | `map.toon.yaml` | **YAML** | **🗺️ Structural map + project header** - Modules, imports, exports, signatures, stats, alerts, hotspots, trend | Project architecture overview |
+| `projections.json` | **JSON** | **🔎 Bounded symbol catalog** (`code2llm.projection/v1`) for intent retrieval / external indexers — deterministic, digested, capped at 2048 records | Reuse contract without analyzer internals |
 
 ### 🤖 LLM-Ready Documentation
 

{code2llm-0.5.183 → code2llm-0.5.185}/README.md

@@ -26,6 +26,7 @@ When you run `code2llm ./ -f all`, the following files are created:
 |------|--------|---------|--------------|
 | `evolution.toon.yaml` | **YAML** | **📋 Refactoring queue** - Prioritized improvements | 0 refactoring actions needed |
 | `map.toon.yaml` | **YAML** | **🗺️ Structural map + project header** - Modules, imports, exports, signatures, stats, alerts, hotspots, trend | Project architecture overview |
+| `projections.json` | **JSON** | **🔎 Bounded symbol catalog** (`code2llm.projection/v1`) for intent retrieval / external indexers — deterministic, digested, capped at 2048 records | Reuse contract without analyzer internals |
 
 ### 🤖 LLM-Ready Documentation
 

code2llm-0.5.185/VERSION

@@ -0,0 +1 @@
+0.5.185

{code2llm-0.5.183 → code2llm-0.5.185}/code2llm/__init__.py

@@ -8,7 +8,7 @@ Includes NLP Processing Pipeline for query normalization, intent matching,
 and entity resolution with multilingual support.
 """
 
-__version__ = "0.5.183"
+__version__ = "0.5.185"
 __author__ = "STTS Project"
 
 # Core analysis components (lightweight, always needed)

{code2llm-0.5.183 → code2llm-0.5.185}/code2llm/analysis/smell_engine.py

@@ -212,22 +212,27 @@ def detect_data_clumps(
 
     for (file, args), funcs in arg_sets.items():
         if len(funcs) >= 2:
-            for func_name in funcs:
+            # Names feed exported ticket identities, so hash/discovery order
+            # must not turn the same finding into a new ticket after restart.
+            ordered_args = sorted(args)
+            ordered_funcs = sorted(funcs)
+            arg_names = ", ".join(ordered_args)
+            for func_name in ordered_funcs:
                 func_info = functions[func_name]
                 smells.append(
                     CodeSmell(
-                        name=f"Data Clump: {', '.join(args)}",
+                        name=f"Data Clump: {arg_names}",
                         type="data_clump",
                         file=func_info.file,
                         line=func_info.line,
                         severity=0.6,
                         description=(
-                            f"Arguments ({', '.join(args)}) are used together"
-                            f" in multiple functions: {', '.join(funcs)}."
+                            f"Arguments ({arg_names}) are used together"
+                            f" in multiple functions: {', '.join(ordered_funcs)}."
                         ),
                         context={
-                            "clump": list(args),
-                            "related_functions": funcs,
+                            "clump": ordered_args,
+                            "related_functions": ordered_funcs,
                         },
                     )
                 )

{code2llm-0.5.183 → code2llm-0.5.185}/code2llm/cli_exports/formats.py

@@ -30,6 +30,8 @@ from code2llm.exporters import (
     EvolutionExporter,
     READMEExporter,
     ProjectYAMLExporter,
+    ProjectionsExporter,
+    PROJECTION_FILENAME,
     ToonViewGenerator,
     ContextViewGenerator,
     ArticleViewGenerator,
@@ -195,6 +197,15 @@ def _export_simple_formats(args, result, output_dir: Path, formats):
         if args.verbose:
             print(f"  - JSON: {filepath}")
 
+    if "projections" in formats:
+        exporter = ProjectionsExporter()
+        filepath = output_dir / PROJECTION_FILENAME
+        t0 = time.monotonic()
+        exporter.export(result, str(filepath))
+        elapsed = time.monotonic() - t0
+        if args.verbose:
+            print(f"  - PROJECTIONS: {filepath} ({elapsed:.2f}s)")
+
 
 def _export_yaml(args, result, output_dir: Path):
     """Export YAML with optional split/separated modes."""

{code2llm-0.5.183 → code2llm-0.5.185}/code2llm/cli_exports/orchestrator_constants.py

@@ -20,6 +20,7 @@ FORMAT_FILENAMES: Dict[str, str] = {
     "planfile": "planfile-tickets.yaml",
     "readme": "README.md",
     "project-yaml": "project.yaml",
+    "projections": "projections.json",
 }
 
 # Files produced per format in dry-run preview
@@ -33,6 +34,7 @@ FORMAT_DRY_RUN_FILES: Dict[str, List[str]] = {
     "yaml": ["analysis.yaml"],
     "json": ["analysis.json"],
     "readme": ["README.md"],
+    "projections": ["projections.json"],
 }
 
 # Human-readable labels
@@ -47,6 +49,7 @@ FORMAT_LABELS: Dict[str, str] = {
     "planfile": "PLANFILE (ticket suggestions)",
     "readme": "README (documentation)",
     "project-yaml": "PROJECT-YAML (single source of truth)",
+    "projections": "PROJECTIONS (intent retrieval)",
 }
 
 # ---------------------------------------------------------------------------

{code2llm-0.5.183 → code2llm-0.5.185}/code2llm/cli_parser.py

@@ -97,7 +97,7 @@ Strategy Options (--strategy):
         default="toon",
         help=(
             "Output formats: toon,map,flow,context,code2logic,yaml,json,mermaid,"
-            "evolution,calls,png,project-yaml,planfile,all (default: toon)"
+            "evolution,calls,png,project-yaml,planfile,projections,all (default: toon)"
         ),
     )
 

{code2llm-0.5.183 → code2llm-0.5.185}/code2llm/exporters/__init__.py

@@ -9,6 +9,7 @@ Available exporters:
   - READMEExporter    → README.md           (documentation of all files)
   - YAMLExporter      → analysis.yaml
   - JSONExporter      → analysis.json
+  - ProjectionsExporter → projections.json (bounded symbol catalog for intent retrieval)
   - MermaidExporter   → *.mmd
 
 Registry API:
@@ -33,6 +34,13 @@ from .base import (
 
 # Standard exporters (auto-registered via @export_format decorator)
 from .json_exporter import JSONExporter
+from .projections_exporter import (
+    MAX_RECORDS,
+    PROJECTION_FILENAME,
+    PROJECTION_SCHEMA,
+    ProjectionsExporter,
+    build_projection,
+)
 from .yaml_exporter import YAMLExporter
 from .mermaid_exporter import MermaidExporter
 from .context_exporter import ContextExporter

code2llm-0.5.185/code2llm/exporters/projections_exporter.py

@@ -0,0 +1,139 @@
+"""Bounded, versioned projections of code2llm analysis for intent retrieval.
+
+Emits ``projections.json``: a deterministic, capped catalog of source
+symbols with provenance (kind, symbol, file, line) and content digests.
+Downstream consumers (e.g. semcod/search) index it without parsing the
+full analysis or importing analyzer internals — the reuse contract is
+this artifact, not the Python API (PLF-035 / issue #25).
+
+Contract invariants:
+  - ``schema`` pins the record shape; ``producer.version`` pins the
+    analyzer. Bumping either invalidates downstream caches by equality
+    of the embedded digests alone.
+  - Byte-deterministic for identical analysis results: canonical JSON
+    (sorted keys), records sorted by (file, line, kind, symbol), no
+    timestamps inside records. ``generated_at`` is optional and never
+    contributes to the digest.
+  - Bounded: at most ``MAX_RECORDS`` records; symbol and file strings
+    truncated at ``FIELD_LIMIT`` characters; ``stats.truncated`` flags
+    an overflow so consumers can refuse silently-stale catalogs.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional
+
+from code2llm import __version__
+
+from .base import BaseExporter, export_format
+
+PROJECTION_SCHEMA = "code2llm.projection/v1"
+PROJECTION_FILENAME = "projections.json"
+MAX_RECORDS = 2048
+FIELD_LIMIT = 200
+
+_KIND_ORDER = {"module": 0, "class": 1, "function": 2}
+
+
+def _canonical(obj: Any) -> str:
+    return json.dumps(obj, sort_keys=True, ensure_ascii=False, separators=(",", ":"))
+
+
+def _digest(obj: Any) -> str:
+    return "sha256:" + hashlib.sha256(_canonical(obj).encode("utf-8")).hexdigest()
+
+
+def _bounded(value: str) -> str:
+    return value[:FIELD_LIMIT]
+
+
+def _record(kind: str, symbol: str, file: str, line: Optional[int]) -> Dict[str, Any]:
+    record: Dict[str, Any] = {"kind": kind, "symbol": _bounded(symbol), "file": _bounded(file)}
+    if line is not None:
+        record["line"] = int(line)
+    record["digest"] = _digest(record)
+    return record
+
+
+def _items(value: Any) -> Iterable[Any]:
+    """Yield info objects from either a Dict[str, Info] or a list."""
+    if isinstance(value, dict):
+        return value.values()
+    return value or []
+
+
+def _iter_records(result: Any) -> Iterable[Dict[str, Any]]:
+    modules = _items(getattr(result, "modules", None))
+    classes = _items(getattr(result, "classes", None))
+    functions = _items(getattr(result, "functions", None))
+    for module in modules:
+        yield _record("module", module.name, module.file, None)
+    for cls in classes:
+        yield _record("class", cls.qualified_name or cls.name, cls.file, cls.line)
+    for func in functions:
+        yield _record("function", func.qualified_name or func.name, func.file, func.line)
+
+
+def build_projection(
+    result: Any,
+    *,
+    max_records: int = MAX_RECORDS,
+    generated_at: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Build the projection document from an :class:`AnalysisResult`.
+
+    Duck-typed on purpose: only ``modules``/``classes``/``functions``
+    (``name``/``qualified_name``/``file``/``line``) are read, so tests and
+    alternative frontends can feed lightweight structures.
+    """
+    records: List[Dict[str, Any]] = list(_iter_records(result))
+    records.sort(key=lambda r: (r["file"], r.get("line", 0), _KIND_ORDER[r["kind"]], r["symbol"]))
+    truncated = len(records) > max_records
+    if truncated:
+        records = records[:max_records]
+
+    stats = getattr(result, "stats", None) or {}
+    document: Dict[str, Any] = {
+        "schema": PROJECTION_SCHEMA,
+        "producer": {"tool": "code2llm", "version": __version__},
+        "project": {
+            "path": _bounded(str(getattr(result, "project_path", "") or "")),
+            "analysis_mode": str(getattr(result, "analysis_mode", "") or ""),
+        },
+        "stats": {
+            "files": int(stats.get("files", 0) or 0),
+            "lines": int(stats.get("lines", 0) or 0),
+            "symbols": len(records),
+            "truncated": truncated,
+        },
+        "records": records,
+        "digest": _digest(records),
+    }
+    if generated_at:
+        document["generated_at"] = generated_at
+    return document
+
+
+@export_format(
+    "projections",
+    description="Bounded symbol projections for intent retrieval (projections.json)",
+    extension=".json",
+)
+class ProjectionsExporter(BaseExporter):
+    """Export the deterministic projections catalog."""
+
+    def export(
+        self,
+        result: Any,
+        output_path: str,
+        generated_at: Optional[str] = None,
+        **kwargs: Any,
+    ) -> Optional[Path]:
+        document = build_projection(result, generated_at=generated_at)
+        path = self._ensure_dir(output_path)
+        payload = json.dumps(document, sort_keys=True, ensure_ascii=False, indent=1) + "\n"
+        self._write_text(path, payload)
+        return path

{code2llm-0.5.183 → code2llm-0.5.185/code2llm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code2llm
-Version: 0.5.183
+Version: 0.5.185
 Summary: High-performance Python code flow analysis with optimized TOON format - CFG, DFG, call graphs, and intelligent code queries
 Home-page: https://github.com/wronai/stts
 Author: Tom Sapletta
@@ -101,6 +101,7 @@ When you run `code2llm ./ -f all`, the following files are created:
 |------|--------|---------|--------------|
 | `evolution.toon.yaml` | **YAML** | **📋 Refactoring queue** - Prioritized improvements | 0 refactoring actions needed |
 | `map.toon.yaml` | **YAML** | **🗺️ Structural map + project header** - Modules, imports, exports, signatures, stats, alerts, hotspots, trend | Project architecture overview |
+| `projections.json` | **JSON** | **🔎 Bounded symbol catalog** (`code2llm.projection/v1`) for intent retrieval / external indexers — deterministic, digested, capped at 2048 records | Reuse contract without analyzer internals |
 
 ### 🤖 LLM-Ready Documentation
 

{code2llm-0.5.183 → code2llm-0.5.185}/code2llm.egg-info/SOURCES.txt

@@ -106,6 +106,7 @@ code2llm/exporters/mermaid_exporter.py
 code2llm/exporters/mermaid_flow_helpers.py
 code2llm/exporters/planfile_tickets.py
 code2llm/exporters/project_yaml_exporter.py
+code2llm/exporters/projections_exporter.py
 code2llm/exporters/readme_exporter.py
 code2llm/exporters/report_generators.py
 code2llm/exporters/toon.py
@@ -190,6 +191,7 @@ code2llm/templates/extract_method.md
 code2llm/templates/move_method.md
 tests/test_advanced_analysis.py
 tests/test_analysis_cache_version.py
+tests/test_analysis_env.py
 tests/test_analyzer.py
 tests/test_cache_invalidation_e2e.py
 tests/test_call_graph_engine.py
@@ -217,6 +219,7 @@ tests/test_persistent_cache.py
 tests/test_pipeline_detector.py
 tests/test_planfile_tickets_exporter.py
 tests/test_project_toon_export.py
+tests/test_projections_exporter.py
 tests/test_prompt_engine.py
 tests/test_prompt_txt.py
 tests/test_refactoring_engine.py

{code2llm-0.5.183 → code2llm-0.5.185}/code2llm.egg-info/top_level.txt

@@ -1,3 +1,2 @@
 code2llm
-code2llm_output
 code2llm_part2

{code2llm-0.5.183 → code2llm-0.5.185}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code2llm"
-version = "0.5.183"
+version = "0.5.185"
 description = "High-performance Python code flow analysis with optimized TOON format - CFG, DFG, call graphs, and intelligent code queries"
 readme = "README.md"
 requires-python = ">=3.10"

{code2llm-0.5.183 → code2llm-0.5.185}/setup.py

@@ -25,7 +25,7 @@ def read_readme():
 
 setup(
     name="code2llm",
-    version="0.5.183",
+    version="0.5.185",
     description="Python code flow analysis tool - CFG, DFG, and call graph extraction",
     long_description=read_readme(),
     long_description_content_type="text/markdown",

code2llm-0.5.185/tests/test_analysis_env.py

@@ -0,0 +1,46 @@
+"""Guardrails for the pinned Python 3.12 analysis environment (PLF-036 / #26).
+
+The analyzer chain clickmd/code2logic -> pfix -> pipreqs cannot run on the
+Python 3.13 application venv: pipreqs 0.5.0 declares Requires-Python
+>=3.8.1,<3.13 and no newer release exists. These tests keep the analysis
+environment script and its documentation discoverable and pinned.
+"""
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+SCRIPT = ROOT / "scripts" / "analysis-env.sh"
+DOCS = ROOT / "docs" / "dependencies.md"
+
+
+def test_analysis_env_script_exists_and_is_executable():
+    assert SCRIPT.is_file()
+    assert SCRIPT.stat().st_mode & 0o111, "analysis-env.sh must be executable"
+
+
+def test_analysis_env_script_pins_python_312_and_locked_sync():
+    content = SCRIPT.read_text(encoding="utf-8")
+    assert 'ANALYSIS_PYTHON="${ANALYSIS_PYTHON:-3.12}"' in content
+    assert "uv sync --locked" in content
+    # The application venv must never be the target of the sync.
+    assert "UV_PROJECT_ENVIRONMENT" in content
+    assert "--all-extras" in content
+
+
+@pytest.mark.parametrize(
+    ("fragment",),
+    [
+        ("pipreqs",),
+        (">=3.8.1,<3.13",),
+        ("scripts/analysis-env.sh",),
+        (".venv-analysis",),
+    ],
+)
+def test_dependency_docs_explain_the_analysis_environment(fragment):
+    assert fragment in DOCS.read_text(encoding="utf-8")
+
+
+def test_gitignore_covers_analysis_environment():
+    ignores = (ROOT / ".gitignore").read_text(encoding="utf-8").splitlines()
+    assert ".venv-analysis/" in ignores

code2llm-0.5.185/tests/test_projections_exporter.py

@@ -0,0 +1,130 @@
+"""Contract tests for the bounded intent-retrieval projection (PLF-035 / #25).
+
+The projection is a reuse contract consumed by external indexers
+(semcod/search): determinism, provenance, bounds and version stamping
+are load-bearing, not incidental.
+"""
+from pathlib import Path
+from types import SimpleNamespace
+
+import pytest
+
+from code2llm import __version__
+from code2llm.exporters.projections_exporter import (
+    FIELD_LIMIT,
+    MAX_RECORDS,
+    PROJECTION_SCHEMA,
+    ProjectionsExporter,
+    build_projection,
+)
+
+
+def _fake_result(modules=(), classes=(), functions=(), stats=None, path="proj", mode="standard"):
+    def mod(name, file):
+        return SimpleNamespace(name=name, file=file)
+
+    def cls(name, file, line):
+        return SimpleNamespace(name=name, qualified_name=f"mod.{name}", file=file, line=line)
+
+    def fn(name, file, line):
+        return SimpleNamespace(name=name, qualified_name=f"mod.{name}", file=file, line=line)
+
+    return SimpleNamespace(
+        modules=[mod(*m) for m in modules],
+        classes=[cls(*c) for c in classes],
+        functions=[fn(*f) for f in functions],
+        stats=stats or {"files": 3, "lines": 100},
+        project_path=path,
+        analysis_mode=mode,
+    )
+
+
+def test_schema_and_producer_version_are_pinned():
+    doc = build_projection(_fake_result())
+    assert doc["schema"] == PROJECTION_SCHEMA
+    assert doc["producer"] == {"tool": "code2llm", "version": __version__}
+
+
+def test_records_carry_source_and_symbol_provenance():
+    doc = build_projection(
+        _fake_result(
+            modules=[("core", "pkg/core/__init__.py")],
+            classes=[("Engine", "pkg/core/engine.py", 12)],
+            functions=[("run", "pkg/core/engine.py", 40)],
+        )
+    )
+    by_kind = {r["kind"]: r for r in doc["records"]}
+    assert by_kind["module"] == {
+        "kind": "module",
+        "symbol": "core",
+        "file": "pkg/core/__init__.py",
+        "digest": by_kind["module"]["digest"],
+    }
+    assert by_kind["class"]["symbol"] == "mod.Engine"
+    assert by_kind["class"]["file"] == "pkg/core/engine.py"
+    assert by_kind["class"]["line"] == 12
+    assert by_kind["function"]["line"] == 40
+    assert all(r["digest"].startswith("sha256:") for r in doc["records"])
+
+
+def test_deterministic_bytes_and_digest():
+    result = _fake_result(
+        classes=[("B", "b.py", 2), ("A", "a.py", 1)],
+        functions=[("z", "a.py", 9), ("a", "b.py", 1)],
+    )
+    first = build_projection(result)
+    second = build_projection(result)
+    assert first == second
+    assert first["digest"] == second["digest"]
+    # Record order is canonical: (file, line, kind, symbol).
+    order = [(r["file"], r.get("line", 0), r["kind"], r["symbol"]) for r in first["records"]]
+    assert order == sorted(order)
+    # generated_at never leaks into the digest.
+    stamped = build_projection(result, generated_at="2026-10-23T00:00:00Z")
+    assert stamped["digest"] == first["digest"]
+
+
+def test_bounds_cap_records_and_flag_truncation():
+    functions = [(f"f{i}", "m.py", i + 1) for i in range(MAX_RECORDS + 5)]
+    doc = build_projection(_fake_result(functions=functions))
+    assert len(doc["records"]) == MAX_RECORDS
+    assert doc["stats"]["truncated"] is True
+    assert doc["stats"]["symbols"] == MAX_RECORDS
+    small = build_projection(_fake_result(functions=functions[:4]))
+    assert small["stats"]["truncated"] is False
+
+
+def test_long_fields_are_truncated():
+    long_name = "x" * (FIELD_LIMIT + 50)
+    doc = build_projection(_fake_result(functions=[(long_name, long_name + ".py", 1)]))
+    record = doc["records"][0]
+    assert len(record["symbol"]) == FIELD_LIMIT
+    assert len(record["file"]) == FIELD_LIMIT
+
+
+def test_exporter_writes_canonical_json(tmp_path: Path):
+    result = _fake_result(classes=[("E", "e.py", 3)])
+    exporter = ProjectionsExporter()
+    out = tmp_path / "projections.json"
+    path = exporter.export(result, str(out))
+    assert path == out and out.exists()
+    body = out.read_text(encoding="utf-8")
+    again = exporter.export(result, str(tmp_path / "again.json"))
+    assert again.read_text(encoding="utf-8") == body
+    assert body.endswith("\n")
+
+
+def test_registry_lists_projections():
+    from code2llm.exporters import EXPORT_REGISTRY, get_exporter
+
+    assert "projections" in EXPORT_REGISTRY
+    assert get_exporter("projections") is ProjectionsExporter
+
+
+def test_cli_help_mentions_projections(capsys):
+    from code2llm.cli_parser import create_parser
+
+    with pytest.raises(SystemExit) as exc:
+        create_parser().parse_args(["--help"])
+    assert exc.value.code == 0
+    assert "projections" in (capsys.readouterr().out or "")

{code2llm-0.5.183 → code2llm-0.5.185}/tests/test_prompt_engine.py

@@ -17,7 +17,7 @@ def test_tiktoken_truncation():
 
     engine = PromptEngine(result)
     # Mock source context to be very large
-    engine._get_source_context = lambda f, l: "print('Hello world')\n" * 1000
+    engine._get_source_context = lambda f, l, *, max_lines: "print('Hello world')\n" * 1000
 
     prompts = engine.generate_prompts()
     assert len(prompts) == 1
@@ -59,7 +59,7 @@ def test_template_rendering_with_metrics():
     }
 
     engine = PromptEngine(result)
-    engine._get_source_context = lambda f, l: "def complex_func():\n    pass"
+    engine._get_source_context = lambda f, l, *, max_lines: "def complex_func():\n    pass"
 
     prompts = engine.generate_prompts()
     prompt_content = list(prompts.values())[0]

{code2llm-0.5.183 → code2llm-0.5.185}/tests/test_smells_data_clumps.py

@@ -81,3 +81,54 @@ def test_fewer_than_three_args_never_counted():
     smells = SmellDetector(result)._detect_data_clumps()
 
     assert smells == []
+
+
+def test_exported_clump_tickets_are_stable_across_processes(tmp_path):
+    """The same finding must not create new ticket keys after a process restart."""
+    import json
+    import os
+    from pathlib import Path
+    import subprocess
+    import sys
+    import textwrap
+
+    script = textwrap.dedent("""\
+        import json
+        import sys
+        from dataclasses import asdict
+        from code2llm.analysis.smells import SmellDetector
+        from code2llm.core.models import AnalysisResult, FunctionInfo
+        from code2llm.exporters.planfile_tickets import _smell_tickets
+
+        reverse = sys.argv[1] == "reverse"
+        functions = [("create_github_pr", 47), ("create_gitlab_mr", 80)]
+        arguments = ["self", "provider", "group", "template"]
+        if reverse:
+            functions.reverse()
+            arguments.reverse()
+        result = AnalysisResult(project_path="/fixture")
+        for name, line in functions:
+            result.functions[name] = FunctionInfo(
+                name=name, qualified_name="publish." + name,
+                file="/fixture/publish.py", line=line, args=arguments,
+            )
+        result.smells = SmellDetector(result)._detect_data_clumps()
+        tickets = [asdict(ticket) for ticket in _smell_tickets(result)]
+        print(json.dumps(sorted(tickets, key=lambda t: t["dedupe_key"]), sort_keys=True))
+        """)
+    outputs = []
+    root = str(Path(__file__).resolve().parents[1])
+    for seed, order in [("1", "forward"), ("2", "forward"), ("42", "reverse")]:
+        env = os.environ.copy()
+        env["PYTHONHASHSEED"] = seed
+        env["PYTHONPATH"] = root + os.pathsep + env.get("PYTHONPATH", "")
+        child = subprocess.run(
+            [sys.executable, "-c", script, order],
+            cwd=tmp_path, env=env, check=True, capture_output=True,
+            text=True, timeout=30,
+        )
+        tickets = json.loads(child.stdout)
+        assert len(tickets) == 2
+        assert len({ticket["dedupe_key"] for ticket in tickets}) == 2
+        outputs.append(tickets)
+    assert outputs[0] == outputs[1] == outputs[2]

code2llm-0.5.183/VERSION

@@ -1 +0,0 @@
-0.5.183