attocode-code-intel 0.1.5__tar.gz → 0.1.6__tar.gz

{attocode_code_intel-0.1.5 → attocode_code_intel-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: attocode-code-intel
-Version: 0.1.5
+Version: 0.1.6
 Summary: Local code search and navigation for coding agents and people
 Project-URL: Homepage, https://github.com/eren23/attocode
 Project-URL: Repository, https://github.com/eren23/attocode
@@ -189,8 +189,8 @@ also found no demonstrated benefit; its reviewed decision is to stop expansion.
 
 - **First search.** The first tool call starts the index build. A search waits up to 15 seconds for the index. On a large repository, a search can report that the index is warming. Then search again. An empty result during warm-up does not prove that the code is absent.
 - **Index location.** The index is in `.attocode/` in your project. When the server makes that folder, it adds a `.gitignore`, so the index stays out of commits.
-- **What the index reads.** The server reads at most 50,000 files and skips files over 1 MB. It skips files that `.gitignore` ignores, and folders that start with a dot. It also skips folders named `build`, `out`, `output`, `target`, `env`, `tmp`, `vendor` or `coverage`, and binary, media and lock files.
-- **Languages.** The base install parses Bash, C, C#, C++, CSS, Elixir, Go, HCL, HTML, Java, JavaScript, JSON, Kotlin, Lua, PHP, Python, Ruby, Rust, Scala, Swift, TOML, TypeScript, YAML and Zig. The `tree-sitter-all` extra adds about 170 more.
+- **What the index reads.** The server reads at most 50,000 files and skips files over 1 MB. It skips files that `.gitignore` ignores, and folders that start with a dot. It also skips folders named `dist`, `build`, `out`, `output`, `target`, `env`, `tmp`, `vendor` or `coverage`, and binary, media and lock files. If a build-named folder contains real source, explicitly re-include it with a root `.gitignore` entry such as `!dist/`; discovery and edit refresh honor that override.
+- **Languages.** The base install parses Bash, C, C#, C++, CSS, Elixir, Go, HCL, HTML, Java, JavaScript, JSON, Kotlin, Lua, PHP, Python, Ruby, Rust, Scala, Swift, TOML, TypeScript, YAML and Zig. Optional grammars are loaded only when already installed or cached; installing the `tree-sitter-all` extra does not trigger grammar downloads during navigation. A slow grammar falls back after a 100 ms parse budget. Static imports and references are partial evidence, not compiler/type resolution.
 - **Remove the setup.** Run `attocode-code-intel init --remove`. It restores an entry that existed before `init`.
 - **Server does not answer.** Run `attocode-code-intel doctor`. If a client shows "not configured", run `init` for it. After a change, restart the agent. In Claude Code, `/mcp` shows the server state.
 - **HTTP server.** `attocode-code-intel --transport http` needs the `http` extra. It serves only this computer unless you set `ATTOCODE_API_KEY`.

{attocode_code_intel-0.1.5 → attocode_code_intel-0.1.6}/README.md

@@ -77,8 +77,8 @@ also found no demonstrated benefit; its reviewed decision is to stop expansion.
 
 - **First search.** The first tool call starts the index build. A search waits up to 15 seconds for the index. On a large repository, a search can report that the index is warming. Then search again. An empty result during warm-up does not prove that the code is absent.
 - **Index location.** The index is in `.attocode/` in your project. When the server makes that folder, it adds a `.gitignore`, so the index stays out of commits.
-- **What the index reads.** The server reads at most 50,000 files and skips files over 1 MB. It skips files that `.gitignore` ignores, and folders that start with a dot. It also skips folders named `build`, `out`, `output`, `target`, `env`, `tmp`, `vendor` or `coverage`, and binary, media and lock files.
-- **Languages.** The base install parses Bash, C, C#, C++, CSS, Elixir, Go, HCL, HTML, Java, JavaScript, JSON, Kotlin, Lua, PHP, Python, Ruby, Rust, Scala, Swift, TOML, TypeScript, YAML and Zig. The `tree-sitter-all` extra adds about 170 more.
+- **What the index reads.** The server reads at most 50,000 files and skips files over 1 MB. It skips files that `.gitignore` ignores, and folders that start with a dot. It also skips folders named `dist`, `build`, `out`, `output`, `target`, `env`, `tmp`, `vendor` or `coverage`, and binary, media and lock files. If a build-named folder contains real source, explicitly re-include it with a root `.gitignore` entry such as `!dist/`; discovery and edit refresh honor that override.
+- **Languages.** The base install parses Bash, C, C#, C++, CSS, Elixir, Go, HCL, HTML, Java, JavaScript, JSON, Kotlin, Lua, PHP, Python, Ruby, Rust, Scala, Swift, TOML, TypeScript, YAML and Zig. Optional grammars are loaded only when already installed or cached; installing the `tree-sitter-all` extra does not trigger grammar downloads during navigation. A slow grammar falls back after a 100 ms parse budget. Static imports and references are partial evidence, not compiler/type resolution.
 - **Remove the setup.** Run `attocode-code-intel init --remove`. It restores an entry that existed before `init`.
 - **Server does not answer.** Run `attocode-code-intel doctor`. If a client shows "not configured", run `init` for it. After a change, restart the agent. In Claude Code, `/mcp` shows the server state.
 - **HTTP server.** `attocode-code-intel --transport http` needs the `http` extra. It serves only this computer unless you set `ATTOCODE_API_KEY`.

attocode_code_intel-0.1.6/evals/ast_restart_probe.py

@@ -0,0 +1,101 @@
+"""Generated Go cold+restart comparison with exact AST/index parity and cleanup."""
+from __future__ import annotations
+
+import ast
+import hashlib
+import json
+import platform
+import subprocess
+import tempfile
+import time
+from dataclasses import asdict
+from pathlib import Path
+from unittest.mock import patch
+
+from attocode_intel._internal.integrations.context import ast_service, ast_snapshot, codebase_ast
+from attocode_intel._internal.integrations.context.index_store import AST_SNAPSHOT_KEY
+
+BASELINE = 'b3501b9d7ae016572d77ceae1289026d23719694'
+SOURCE = 'packages/code-intel/src/attocode_intel/_internal/integrations/context/ast_service.py'
+
+
+def run():
+    source = subprocess.check_output(['git', 'show', f'{BASELINE}:{SOURCE}'], timeout=10)
+    cls = next(n for n in ast.parse(source).body if isinstance(n, ast.ClassDef) and n.name == 'ASTService')
+    methods, scopes = {}, []
+    for name in ('initialize_skeleton', '_save_snapshot', '_restore_snapshot'):
+        method = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == name)
+        scope = dict(vars(ast_service))
+        exec(compile(ast.Module(body=[method], type_ignores=[]), '<frozen restart>', 'exec'), scope)
+        methods[name] = scope[name]
+        scopes.append(scope)
+    original = {name: getattr(ast_service.ASTService, name) for name in methods}
+    observations = []
+    with tempfile.TemporaryDirectory(prefix='attocode-restart-probe-') as tmp:
+        root = Path(tmp)
+        workloads = ['short_body', 'long_body']
+        source_sizes = {}
+        for number, (workload, mode) in enumerate((w, m) for w in workloads
+                for m in ['baseline', 'candidate', 'candidate', 'baseline']):
+            for scope in scopes:
+                scope['parse_file'] = ast_service.parse_file
+            project = root / str(number)
+            project.mkdir()
+            for i in range(160):
+                (project / f'file{i:04d}.go').write_text('package example\n' + ''.join(
+                    f'// Helper{i}_{j} returns an adjusted value.\nfunc Helper{i}_{j}(value int) int {{\n'
+                    + '    if value < 0 { return 0 }\n' * (1 if workload == 'short_body' else 12)
+                    + '    return value + 1\n}\n' for j in range(32)))
+            source_sizes[workload] = sum(p.stat().st_size for p in project.iterdir())
+            assert source_sizes[workload] < 8 * 2**20
+            with patch.multiple(ast_service.ASTService, **(methods if mode == 'baseline' else original)):
+                first = ast_service.ASTService(str(project))
+                start = time.monotonic()
+                try:
+                    first.initialize_skeleton(indexing_depth='eager')
+                    cold = time.monotonic() - start
+                    payload_bytes = len((first._store.get_meta(AST_SNAPSHOT_KEY) or '').encode())
+                finally:
+                    first.stop_hydration()
+                    first._store.close()
+                second = ast_service.ASTService(str(project))
+                try:
+                    with (patch.object(ast_service, 'parse_file', wraps=ast_service.parse_file) as parse,
+                          patch.object(codebase_ast, 'parse_file', parse)):
+                        for scope in scopes:
+                            scope['parse_file'] = parse
+                        wall, cpu = time.monotonic(), time.thread_time()
+                        state = second.initialize_skeleton()
+                        restart, thread_cpu = time.monotonic()-wall, time.thread_time()-cpu
+                        calls = parse.call_count
+                    assert state.phase == 'ready' and state.parsed_files == 160
+                    assert calls == (320 if mode == 'baseline' else 0)
+                    summaries = {key: {**asdict(value), 'path': key} for key, value in second._ast_cache.items()}
+                    evidence = {'asts': summaries, 'definitions': {
+                        key: [asdict(v) for v in value] for key, value in second._index.definitions.items()},
+                        'stats': second._store.stats(), 'dependencies': {
+                            key: sorted(value) for key, value in second._index.file_dependencies.items()}}
+                    digest = hashlib.sha256(json.dumps(evidence, sort_keys=True).encode()).hexdigest()
+                    observations.append({'mode': mode, 'workload': workload, 'cold_seconds': cold, 'restart_seconds': restart,
+                                         'cold_plus_restart_seconds': cold+restart, 'restart_thread_cpu_seconds': thread_cpu,
+                                         'restart_parse_calls': calls, 'cache_payload_bytes': payload_bytes,
+                                         'evidence_sha256': digest})
+                finally:
+                    second.stop_hydration()
+                    second._store.close()
+        for workload in workloads:
+            assert len({row['evidence_sha256'] for row in observations if row['workload'] == workload}) == 1
+        disk_bytes = sum(p.stat().st_size for p in root.rglob('*') if p.is_file())
+        assert disk_bytes < 100 * 2**20
+    return {'scope': 'Generated 160-file/5120-function Go cold+restart; no Cockroach or cloud speed claim',
+            'baseline_commit': BASELINE, 'baseline_source_sha256': hashlib.sha256(source).hexdigest(),
+            'candidate_source_sha256': hashlib.sha256(Path(ast_service.__file__).read_bytes()).hexdigest(),
+            'cache_source_sha256': hashlib.sha256(Path(ast_snapshot.__file__).read_bytes()).hexdigest(),
+            'probe_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+            'python': platform.python_version(), 'platform': platform.platform(),
+            'source_bytes': source_sizes, 'final_owned_disk_bytes': disk_bytes,
+            'observations': observations, 'cleanup_verified': not root.exists()}
+
+
+if __name__ == '__main__':
+    print(json.dumps(run(), indent=2))

attocode_code_intel-0.1.6/evals/body_cost_probe.py

@@ -0,0 +1,101 @@
+"""Bounded generated body-work probe: no downloads, models or cloud resources.
+
+This isolates document generation, using empty known spans (no AST parsing), not
+an end-to-end repository benchmark. Compare identical terms/windows by digest.
+"""
+from __future__ import annotations
+
+import argparse
+import ast
+import hashlib
+import inspect
+import json
+import platform
+import subprocess
+import tempfile
+import time
+from contextlib import nullcontext
+from functools import partial
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from attocode_intel._internal.integrations.context import index_probe as probe
+from attocode_intel._internal.integrations.context import semantic_search as search
+
+BASELINE = "3d7c41ca628e8dfd2f62cf7eff9c4ae3aadbbdc2"
+SOURCE = "packages/code-intel/src/attocode_intel/_internal/integrations/context/semantic_search.py"
+
+
+def baseline_body():
+    source = subprocess.check_output(["git", "show", f"{BASELINE}:{SOURCE}"], timeout=10)
+    cls = next(n for n in ast.parse(source).body if isinstance(n, ast.ClassDef) and n.name == "SemanticSearchManager")
+    method = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == "_body_document")
+    method.decorator_list = []
+    scope = dict(vars(search))
+    exec(compile(ast.Module(body=[method], type_ignores=[]), "<frozen body>", "exec"), scope)
+    return scope[method.name], hashlib.sha256(source).hexdigest()
+
+
+def fixture(root, unique=False):
+    paths = []
+    for i in range(8):
+        path = root / f'generated{i}.go'
+        path.write_text('package example\n' + ''.join(
+            f'// block {n if unique else n // 32}\nvalue_{n if unique else n % 64} = otherHTTPValue + processRow(value_{n if unique else n % 64})\n'
+            for n in range(2048)
+        ))
+        paths.append(path)
+    return paths
+
+
+def run():
+    observations = []
+    legacy, baseline_hash = baseline_body()
+    source_bytes = {}
+    with tempfile.TemporaryDirectory(prefix='attocode-body-cost-') as tmp:
+        for workload in ('repeated', 'unique'):
+            root = Path(tmp) / workload
+            root.mkdir()
+            paths = fixture(root, unique=workload == 'unique')
+            source_bytes[workload] = sum(p.stat().st_size for p in paths)
+            assert source_bytes[workload] < 2 * 2**20
+            modes = ['baseline_off', 'off', 'all_calls', 'default']
+            for rotation in range(4):
+                for mode in modes[rotation:] + modes[:rotation]:
+                    collector = None if mode in ('baseline_off', 'off') else probe.IndexProbe()
+                    wrapping = (patch.object(search, 'instrument', lambda phase, fn:
+                                partial(probe.measured_call, phase, fn))
+                                if mode == 'all_calls' else nullcontext())
+                    method = legacy if mode == 'baseline_off' else search.SemanticSearchManager._body_document
+                    outputs = []
+                    with wrapping, probe.activate(collector):
+                        wall, cpu = time.monotonic(), time.thread_time()
+                        for p in paths:
+                            outputs.append(method(
+                                p.name, str(p), SimpleNamespace(take=lambda *_: ([], [])),
+                                include_file_terms=True,
+                            ))
+                        elapsed, used = time.monotonic()-wall, time.thread_time()-cpu
+                    digest = hashlib.sha256(json.dumps(outputs, ensure_ascii=False).encode()).hexdigest()
+                    observations.append({'workload': workload, 'mode': mode, 'rotation': rotation,
+                                         'wall_seconds': elapsed, 'thread_cpu_seconds': used,
+                                         'output_sha256': digest,
+                                         'windows': sum(len(o[0]) for o in outputs),
+                                         'profile': collector.snapshot() if collector else None})
+            assert len({o['output_sha256'] for o in observations if o['workload'] == workload}) == 1
+    return {'scope': 'Generated document generation, empty known spans; no parsing, SQL or cold-start claim',
+            'baseline_commit': BASELINE, 'baseline_source_sha256': baseline_hash,
+            'candidate_source_sha256': hashlib.sha256(Path(inspect.getfile(search)).read_bytes()).hexdigest(),
+            'profiler_sha256': hashlib.sha256(Path(inspect.getfile(probe)).read_bytes()).hexdigest(),
+            'probe_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+            'python': platform.python_version(), 'platform': platform.platform(),
+            'source_bytes': source_bytes, 'observations': observations,
+            'cleanup_verified': not Path(tmp).exists()}
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--output', type=Path, required=True)
+    args = parser.parse_args()
+    args.output.write_text(json.dumps(run(), indent=2)+'\n')

attocode_code_intel-0.1.6/evals/discovery_reuse_probe.py

@@ -0,0 +1,63 @@
+"""Bounded two-consumer discovery comparison, not a cold-start performance gate."""
+from __future__ import annotations
+
+import ast
+import hashlib
+import inspect
+import json
+import platform
+import subprocess
+import tempfile
+import time
+from dataclasses import asdict
+from pathlib import Path
+
+from attocode_intel._internal.integrations.context import codebase_context as context
+from attocode_intel._internal.integrations.context import discovery_snapshot
+
+BASELINE = '3d7c41ca628e8dfd2f62cf7eff9c4ae3aadbbdc2'
+SOURCE = 'packages/code-intel/src/attocode_intel/_internal/integrations/context/codebase_context.py'
+
+
+def run():
+    source = subprocess.check_output(['git', 'show', f'{BASELINE}:{SOURCE}'], timeout=10)
+    cls = next(n for n in ast.parse(source).body if isinstance(n, ast.ClassDef) and n.name == 'CodebaseContextManager')
+    method = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == 'discover_files')
+    scope = dict(vars(context))
+    exec(compile(ast.Module(body=[method], type_ignores=[]), '<frozen discovery>', 'exec'), scope)
+    legacy = scope['discover_files']
+    observations = []
+    with tempfile.TemporaryDirectory(prefix='attocode-discovery-cost-') as tmp:
+        root = Path(tmp)
+        for i in range(640):
+            (root / f'f{i}.py').write_text(f'def helper_{i}():\n    return "meaningfulValue"\n' * 4)
+        source_bytes = sum(p.stat().st_size for p in root.iterdir())
+        assert source_bytes < 2**20
+        for order in [('baseline', 'reuse'), ('reuse', 'baseline'), ('baseline', 'reuse')]:
+            for mode in order:
+                donor = context.CodebaseContextManager(tmp, max_files=100000)
+                consumer = context.CodebaseContextManager(tmp)
+                wall, cpu = time.monotonic(), time.thread_time()
+                (legacy(donor) if mode == 'baseline' else donor.discover_files())
+                donor_seconds = time.monotonic() - wall
+                if mode == 'baseline':
+                    legacy(consumer)
+                else:
+                    assert consumer.reuse_discovery(donor._discovery_snapshot)
+                seconds, used = time.monotonic()-wall, time.thread_time()-cpu
+                files = [{k:v for k,v in asdict(f).items() if k != 'path'} for f in consumer._files]
+                observations.append({'mode':mode,'wall_seconds':seconds,'thread_cpu_seconds':used,
+                                     'donor_seconds':donor_seconds,'consumer_seconds':seconds-donor_seconds,
+                                     'files':len(files),'inventory_sha256':hashlib.sha256(json.dumps(files).encode()).hexdigest()})
+        assert len({o['inventory_sha256'] for o in observations}) == 1
+    return {'scope':'Generated 640-file two-consumer inventory work; no cloud or cold-gate claim',
+            'baseline_commit':BASELINE,'baseline_source_sha256':hashlib.sha256(source).hexdigest(),
+            'candidate_source_sha256':hashlib.sha256(Path(inspect.getfile(context)).read_bytes()).hexdigest(),
+            'snapshot_source_sha256':hashlib.sha256(Path(inspect.getfile(discovery_snapshot)).read_bytes()).hexdigest(),
+            'probe_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+            'python':platform.python_version(),'platform':platform.platform(),
+            'source_bytes':source_bytes,'observations':observations,'cleanup_verified':not root.exists()}
+
+
+if __name__ == '__main__':
+    print(json.dumps(run(),indent=2))

attocode_code_intel-0.1.6/evals/lexical_sql_probe.py

@@ -0,0 +1,171 @@
+"""Bounded lexical SQL diagnostic; synthetic contention, no cloud or model calls.
+
+Baseline must already exist locally. Disposable databases are removed; each
+competitor stops after 20 seconds. One observation per case is not a timing gate.
+"""
+
+import ast
+import hashlib
+import inspect
+import json
+import platform
+import subprocess
+import tempfile
+import threading
+import time
+from functools import partial
+from pathlib import Path
+from types import SimpleNamespace
+
+from attocode_intel._internal.integrations.context import semantic_search as search
+
+BASELINE = "4f33254130fb2817c44cfa7a57e3e213822b9560"
+SOURCE = "packages/code-intel/src/attocode_intel/_internal/integrations/context/semantic_search.py"
+source = subprocess.check_output(["git", "show", f"{BASELINE}:{SOURCE}"], timeout=10)
+cls = next(
+    n
+    for n in ast.parse(source).body
+    if isinstance(n, ast.ClassDef) and n.name == "SemanticSearchManager"
+)
+scope = dict(vars(search))
+for name in ("_save_kw_cache", "_sync_body_index"):
+    method = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == name)
+    exec(
+        compile(ast.Module(body=[method], type_ignores=[]), "<frozen baseline method>", "exec"),
+        scope,
+    )
+legacy_cache, legacy_body = scope["_save_kw_cache"], scope["_sync_body_index"]
+
+
+def cpu(stop):
+    end = time.monotonic() + 20
+    while not stop.is_set() and time.monotonic() < end:
+        sum(i * i for i in range(10000))
+
+
+def measure(fn, contended):
+    stop = threading.Event()
+    worker = threading.Thread(target=cpu, args=(stop,))
+    if contended:
+        worker.start()
+    started = time.monotonic()
+    try:
+        fn()
+        elapsed = time.monotonic() - started
+        full = worker.is_alive() if contended else None
+    finally:
+        stop.set()
+        if contended:
+            worker.join()
+    return elapsed, full
+
+
+results = []
+with tempfile.TemporaryDirectory(prefix="quality-lexical-sql-") as scratch:
+    for task in ["keyword", "body_delete"]:
+        for contended in [False, True]:
+            for arm in ["legacy", "batched"]:
+                root = Path(scratch) / f"{task}-{contended}-{arm}"
+                root.mkdir()
+                mgr = search.SemanticSearchManager(str(root))
+                try:
+                    if task == "keyword":
+                        documents = [
+                            search._KeywordDoc(
+                                f"func:{i}",
+                                f"f{i % 256}.py",
+                                "function",
+                                f"helper{i}",
+                                "preview",
+                                False,
+                                False,
+                                {"needle": 2},
+                                2,
+                            )
+                            for i in range(2048)
+                        ]
+                        mtimes = {f"f{i}.py": 1.0 for i in range(256)}
+                        method = (
+                            legacy_cache
+                            if arm == "legacy"
+                            else search.SemanticSearchManager._save_kw_cache
+                        )
+                        elapsed, full = measure(partial(method, mgr, documents, mtimes), contended)
+                        conn = mgr._open_kw_cache_db()
+                        rows = [
+                            conn.execute(f"SELECT rowid,* FROM {t} ORDER BY rowid").fetchall()
+                            for t in ["kw_files", "kw_docs"]
+                        ]
+                    else:
+                        paths = [root / f"f{i:03}.py" for i in range(133)]
+                        for p in paths:
+                            p.write_text("def helper(): return 1\n")
+
+                        def ctx(ps):
+                            return SimpleNamespace(
+                                _ensure_fresh=lambda: None,
+                                _files=[
+                                    SimpleNamespace(path=str(p), relative_path=p.name) for p in ps
+                                ],
+                            )
+
+                        mgr._sync_body_index(ctx(paths))
+                        assert mgr._body_index_built
+                        mgr._body_index_built = False
+                        method = (
+                            legacy_body
+                            if arm == "legacy"
+                            else search.SemanticSearchManager._sync_body_index
+                        )
+                        elapsed, full = measure(partial(method, mgr, ctx(paths[-1:])), contended)
+                        assert mgr._body_index_built
+                        conn = mgr._open_body_db()
+                        rows = [
+                            conn.execute(f"SELECT rowid,* FROM {t} ORDER BY rowid").fetchall()
+                            for t in ["body_fts", "body_file_fts"]
+                        ]
+                        rows.append(
+                            conn.execute(
+                                "SELECT file_path,size FROM body_files ORDER BY file_path"
+                            ).fetchall()
+                        )
+                    conn.close()
+                    results.append(
+                        dict(
+                            task=task,
+                            arm=arm,
+                            cpu_thread=contended,
+                            seconds=elapsed,
+                            competitor_active_at_end=full,
+                            row_counts=[len(r) for r in rows],
+                            row_sha256=hashlib.sha256(json.dumps(rows).encode()).hexdigest(),
+                        )
+                    )
+                finally:
+                    mgr.close()
+for task in ["keyword", "body_delete"]:
+    assert len({r["row_sha256"] for r in results if r["task"] == task}) == 1
+print(
+    json.dumps(
+        dict(
+            baseline_commit=BASELINE,
+            baseline_source_sha256=hashlib.sha256(source).hexdigest(),
+            candidate_source_sha256=hashlib.sha256(
+                Path(inspect.getfile(search)).read_bytes()
+            ).hexdigest(),
+            probe_sha256=hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+            python=platform.python_version(),
+            platform=platform.platform(),
+            fixture={
+                "keyword_docs": 2048,
+                "keyword_files": 256,
+                "body_files": 133,
+                "body_files_deleted": 132,
+            },
+            scope="Single observations, synthetic CPU contention; not cloud latency or release evidence",
+            results=results,
+            cleanup_verified=True,
+        ),
+        indent=2,
+    )
+)

attocode_code_intel-0.1.6/evals/restart_discovery_probe.py

@@ -0,0 +1,101 @@
+"""Generated comparison of discovery parsing before/after cached structural restart."""
+from __future__ import annotations
+
+import ast
+import hashlib
+import json
+import platform
+import subprocess
+import tempfile
+import time
+from dataclasses import asdict
+from pathlib import Path
+from unittest.mock import patch
+
+from attocode_intel._internal.integrations.context import ast_service, ast_snapshot, codebase_ast
+from attocode_intel._internal.integrations.context.index_store import AST_SNAPSHOT_KEY
+
+BASELINE = 'e97f986532a3612542326ae21c0360e0b83fc2bc'
+SOURCE = 'packages/code-intel/src/attocode_intel/_internal/integrations/context/ast_service.py'
+
+
+def run():
+    source = subprocess.check_output(['git', 'show', f'{BASELINE}:{SOURCE}'], timeout=10)
+    cls = next(n for n in ast.parse(source).body if isinstance(n, ast.ClassDef) and n.name == 'ASTService')
+    methods, scopes = {}, []
+    for name in ('initialize_skeleton', '_save_snapshot', '_restore_snapshot'):
+        method = next(n for n in cls.body if isinstance(n, ast.FunctionDef) and n.name == name)
+        scope = dict(vars(ast_service))
+        exec(compile(ast.Module(body=[method], type_ignores=[]), '<frozen restart>', 'exec'), scope)
+        methods[name] = scope[name]
+        scopes.append(scope)
+    original = {name: getattr(ast_service.ASTService, name) for name in methods}
+    observations = []
+    with tempfile.TemporaryDirectory(prefix='attocode-restart-probe-') as tmp:
+        root = Path(tmp)
+        workloads = ['short_body', 'long_body']
+        source_sizes = {}
+        for number, (workload, mode) in enumerate((w, m) for w in workloads
+                for m in ['baseline', 'candidate', 'candidate', 'baseline']):
+            for scope in scopes:
+                scope['parse_file'] = ast_service.parse_file
+            project = root / str(number)
+            project.mkdir()
+            for i in range(160):
+                (project / f'file{i:04d}.go').write_text('package example\n' + ''.join(
+                    f'// Helper{i}_{j} returns an adjusted value.\nfunc Helper{i}_{j}(value int) int {{\n'
+                    + '    if value < 0 { return 0 }\n' * (1 if workload == 'short_body' else 12)
+                    + '    return value + 1\n}\n' for j in range(32)))
+            source_sizes[workload] = sum(p.stat().st_size for p in project.iterdir())
+            assert source_sizes[workload] < 8 * 2**20
+            with patch.multiple(ast_service.ASTService, **(methods if mode == 'baseline' else original)):
+                first = ast_service.ASTService(str(project))
+                start = time.monotonic()
+                try:
+                    first.initialize_skeleton(indexing_depth='eager')
+                    cold = time.monotonic() - start
+                    payload_bytes = len((first._store.get_meta(AST_SNAPSHOT_KEY) or '').encode())
+                finally:
+                    first.stop_hydration()
+                    first._store.close()
+                second = ast_service.ASTService(str(project))
+                try:
+                    with (patch.object(ast_service, 'parse_file', wraps=ast_service.parse_file) as parse,
+                          patch.object(codebase_ast, 'parse_file', parse)):
+                        for scope in scopes:
+                            scope['parse_file'] = parse
+                        wall, cpu = time.monotonic(), time.thread_time()
+                        state = second.initialize_skeleton()
+                        restart, thread_cpu = time.monotonic()-wall, time.thread_time()-cpu
+                        calls = parse.call_count
+                    assert state.phase == 'ready' and state.parsed_files == 160
+                    assert calls == (160 if mode == 'baseline' else 0)
+                    summaries = {key: {**asdict(value), 'path': key} for key, value in second._ast_cache.items()}
+                    evidence = {'asts': summaries, 'definitions': {
+                        key: [asdict(v) for v in value] for key, value in second._index.definitions.items()},
+                        'stats': second._store.stats(), 'dependencies': {
+                            key: sorted(value) for key, value in second._index.file_dependencies.items()}}
+                    digest = hashlib.sha256(json.dumps(evidence, sort_keys=True).encode()).hexdigest()
+                    observations.append({'mode': mode, 'workload': workload, 'cold_seconds': cold, 'restart_seconds': restart,
+                                         'cold_plus_restart_seconds': cold+restart, 'restart_thread_cpu_seconds': thread_cpu,
+                                         'restart_parse_calls': calls, 'cache_payload_bytes': payload_bytes,
+                                         'evidence_sha256': digest})
+                finally:
+                    second.stop_hydration()
+                    second._store.close()
+        for workload in workloads:
+            assert len({row['evidence_sha256'] for row in observations if row['workload'] == workload}) == 1
+        disk_bytes = sum(p.stat().st_size for p in root.rglob('*') if p.is_file())
+        assert disk_bytes < 100 * 2**20
+    return {'scope': 'Generated 160-file/5120-function Go cold+restart; both parse entry points counted; no Cockroach or cloud speed claim',
+            'baseline_commit': BASELINE, 'baseline_source_sha256': hashlib.sha256(source).hexdigest(),
+            'candidate_source_sha256': hashlib.sha256(Path(ast_service.__file__).read_bytes()).hexdigest(),
+            'cache_source_sha256': hashlib.sha256(Path(ast_snapshot.__file__).read_bytes()).hexdigest(),
+            'probe_sha256': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(),
+            'python': platform.python_version(), 'platform': platform.platform(),
+            'source_bytes': source_sizes, 'final_owned_disk_bytes': disk_bytes,
+            'observations': observations, 'cleanup_verified': not root.exists()}
+
+
+if __name__ == '__main__':
+    print(json.dumps(run(), indent=2))