attocode-code-intel 0.1.11__tar.gz → 0.1.12__tar.gz

{attocode_code_intel-0.1.11 → attocode_code_intel-0.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: attocode-code-intel
-Version: 0.1.11
+Version: 0.1.12
 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
@@ -145,7 +145,9 @@ summaries, with `--class-mode expand` for class-wide callers. Version 0.1.9 keep
 Python docstrings and parameter types, and lists impact results nearest first.
 Version 0.1.10 shows the best test hit second for "tested" searches, and counts
 Swift `Tests/` folders as tests. Version 0.1.11 counts more test file names as
-tests, such as `_test.dart` and Perl `.t` scripts and `t/` modules. See the [change investigation guide](https://github.com/eren23/attocode/blob/main/docs/guides/change-investigation.md).
+tests, such as `_test.dart` and Perl `.t` scripts and `t/` modules. Version
+0.1.12 makes `doctor --client claude` read the local-scope entry that
+`claude mcp add` writes to `~/.claude.json`. See the [change investigation guide](https://github.com/eren23/attocode/blob/main/docs/guides/change-investigation.md).
 
 The agent sees 16 tools (the `daily` profile):
 

{attocode_code_intel-0.1.11 → attocode_code_intel-0.1.12}/README.md

@@ -32,7 +32,9 @@ summaries, with `--class-mode expand` for class-wide callers. Version 0.1.9 keep
 Python docstrings and parameter types, and lists impact results nearest first.
 Version 0.1.10 shows the best test hit second for "tested" searches, and counts
 Swift `Tests/` folders as tests. Version 0.1.11 counts more test file names as
-tests, such as `_test.dart` and Perl `.t` scripts and `t/` modules. See the [change investigation guide](https://github.com/eren23/attocode/blob/main/docs/guides/change-investigation.md).
+tests, such as `_test.dart` and Perl `.t` scripts and `t/` modules. Version
+0.1.12 makes `doctor --client claude` read the local-scope entry that
+`claude mcp add` writes to `~/.claude.json`. See the [change investigation guide](https://github.com/eren23/attocode/blob/main/docs/guides/change-investigation.md).
 
 The agent sees 16 tools (the `daily` profile):
 

attocode_code_intel-0.1.12/evals/designs/2026-10-19-cpu-fn-embed-cost.json

@@ -0,0 +1,33 @@
+{
+  "name": "CPU cost of function-unit CodeRankEmbed embeddings",
+  "date": "2026-10-19",
+  "question": "Can product search embed function units with nomic-ai/CodeRankEmbed on a CPU, as an opt-in mode, at an acceptable index time, query time and memory?",
+  "model": "nomic-ai/CodeRankEmbed at revision 3c4b60807d71f79b43f3c4363786d9493691f8b1 (eval.matrix.dense.MODEL_REVISION)",
+  "units": "Product discovery (CodebaseContextManager.discover_files) and product parse_file: every top-level function and every class method, all parsed languages, test files included and counted separately. Text: relative path, newline, source lines of the unit.",
+  "repos": {
+    "fastapi": ["fastapi/fastapi", "11614be9021aa4ac078d4d0693a8b5250a1010d8"],
+    "express": ["expressjs/express", "6c4249feec8ab40631817c8e7001baf2ed022224"],
+    "cli": ["cli/cli", "6e49747f49f31c9c0a68cfa344df7262a684e723"],
+    "pandas": ["pandas-dev/pandas", "0039f168fe057b945e8ec2a65c9d1e973c7c1fe9"],
+    "cockroach": ["cockroachdb/cockroach", "53aadff3cedde4d810c72b69ddd96e6a735d93e7"]
+  },
+  "configs": ["fp32-512-4", "fp32-512-8", "fp32-1024-8", "int8-512-8"],
+  "config_meaning": "weights - max tokens per unit - CPU threads. Each config runs in its own process, pinned with taskset to that many vCPUs; torch and OpenMP use the same thread count. The GPU is not used.",
+  "measure": {
+    "sample": "1,000 units per repo (all units if fewer), random.Random(0); seconds per unit times the unit count gives the full index time",
+    "check": "one full index of cli/cli with fp32-512-8; it must fall within 20 percent of its estimate, else every estimate is reported as unreliable",
+    "query": "50 workflow-pack query texts with the query prefix, one at a time, after 5 warm-up calls; p50 and p95",
+    "memory": "peak RSS of each config process",
+    "int8": "cosine of each int8 sample vector to its fp32 vector"
+  },
+  "rule": {
+    "pass": "At least one config with 8 threads meets all of: query p95 <= 150 ms; estimated full index <= 10 min for the median repo (by unit count) and <= 60 min for the largest; peak RSS <= 2 GiB. An int8 config counts only if its mean cosine to fp32 is >= 0.99.",
+    "on_pass": "Next step: an opt-in product mode and a quality test on Loc-Bench and fresh questions. A pass is not a quality result.",
+    "on_fail": "Report which limit fails and by how much. Do not tune the limits after the run."
+  },
+  "limits": [
+    "RunPod x86 server vCPUs (hyperthreads), not Apple Silicon. A Mac can use MPS, which is not measured here.",
+    "No retrieval quality is measured. The 0.739 Acc@5 of #241 used bf16, 1,024 tokens, Python-only CoRNStack units, on a GPU."
+  ],
+  "budget": "RunPod $2 cap, one pod, destroyed by node name within 100 minutes of creation."
+}

attocode_code_intel-0.1.12/evals/results/2026-10-19-cpu-fn-embed-cost.json

@@ -0,0 +1,365 @@
+{
+ "schema": 1,
+ "date": "2026-10-19",
+ "source": "94471b6",
+ "design": {
+  "path": "packages/code-intel/evals/designs/2026-10-19-cpu-fn-embed-cost.json",
+  "sha256": "94c1bff807a7f9f30252d81767ee5f860f647f810167e65dcbfad4b68bb330f7"
+ },
+ "script": {
+  "path": "eval/matrix/function_embed_cost.py",
+  "frozen_sha256": "a315e3a1c0ff6fc9a08736821e77c5c74e56ff865b9e527a12856829628e6823",
+  "committed_sha256": "4598311225a9022c4dd9444def816f5f6fa8915f67861699556e7f78c1bff2f7",
+  "committed_change": "The rule path points to the design file; a docstring fix; two Ruff fixes. The measurement code is the same."
+ },
+ "host": {
+  "provider": "RunPod",
+  "gpu_type": "RTX PRO 4500 SE (not used)",
+  "cpu": "AMD EPYC 7282 16-Core Processor (Zen 2)",
+  "visible_vcpus": 64,
+  "cgroup_cpu_quota": 13.6,
+  "cgroup_note": "cgroup v1; the script reads only cgroup v2, so its JSON records cpu_max null. The quota was read by hand.",
+  "torch": "2.8.0+cu128",
+  "sentence_transformers": "3.4.1",
+  "transformers": "4.51.3"
+ },
+ "units": {
+  "fastapi": {
+   "repo": "fastapi/fastapi",
+   "commit": "11614be9021aa4ac078d4d0693a8b5250a1010d8",
+   "files": 2640,
+   "units": 4583,
+   "discovered": 2646,
+   "discovery_truncated": true,
+   "test_units": 3491,
+   "discover_s": 2.41,
+   "parse_s": 0.84,
+   "tokens": {
+    "p50": 91,
+    "p90": 264,
+    "max": 44828,
+    "over_512": 292,
+    "over_1024": 105,
+    "sum_capped_512": 598867,
+    "sum_capped_1024": 698042
+   }
+  },
+  "express": {
+   "repo": "expressjs/express",
+   "commit": "6c4249feec8ab40631817c8e7001baf2ed022224",
+   "files": 158,
+   "units": 175,
+   "discovered": 201,
+   "discovery_truncated": false,
+   "test_units": 30,
+   "discover_s": 0.19,
+   "parse_s": 0.39,
+   "tokens": {
+    "p50": 73,
+    "p90": 205,
+    "max": 664,
+    "over_512": 4,
+    "over_1024": 0,
+    "sum_capped_512": 19614,
+    "sum_capped_1024": 20055
+   }
+  },
+  "cli": {
+   "repo": "cli/cli",
+   "commit": "6e49747f49f31c9c0a68cfa344df7262a684e723",
+   "files": 904,
+   "units": 4893,
+   "discovered": 1050,
+   "discovery_truncated": false,
+   "test_units": 1659,
+   "discover_s": 2.06,
+   "parse_s": 0.6,
+   "tokens": {
+    "p50": 180,
+    "p90": 817,
+    "max": 33657,
+    "over_512": 971,
+    "over_1024": 336,
+    "sum_capped_512": 1172201,
+    "sum_capped_1024": 1476788
+   }
+  },
+  "pandas": {
+   "repo": "pandas-dev/pandas",
+   "commit": "0039f168fe057b945e8ec2a65c9d1e973c7c1fe9",
+   "files": 1658,
+   "units": 31056,
+   "discovered": 2337,
+   "discovery_truncated": true,
+   "test_units": 20979,
+   "discover_s": 7.1,
+   "parse_s": 1.16,
+   "tokens": {
+    "p50": 148,
+    "p90": 415,
+    "max": 9050,
+    "over_512": 2080,
+    "over_1024": 460,
+    "sum_capped_512": 5820897,
+    "sum_capped_1024": 6330441
+   }
+  },
+  "cockroach": {
+   "repo": "cockroachdb/cockroach",
+   "commit": "53aadff3cedde4d810c72b69ddd96e6a735d93e7",
+   "files": 8462,
+   "units": 80319,
+   "discovered": 18850,
+   "discovery_truncated": true,
+   "test_units": 7727,
+   "discover_s": 3.32,
+   "parse_s": 2.45,
+   "tokens": {
+    "p50": 103,
+    "p90": 576,
+    "max": 202355,
+    "over_512": 9382,
+    "over_1024": 3403,
+    "sum_capped_512": 14235911,
+    "sum_capped_1024": 17157451
+   }
+  }
+ },
+ "results": {
+  "fp32-512-8": {
+   "load_s": 19.17,
+   "rss_after_load_mib": 1882.9,
+   "peak_rss_mib": 2107.4,
+   "query_ms": {
+    "n": 50,
+    "p50": 51.7,
+    "p95": 52.9,
+    "max": 55.0
+   },
+   "repos": {
+    "fastapi": {
+     "sample": 1000,
+     "seconds": 122.0,
+     "units_per_s": 8.2,
+     "estimate_full_min": 9.32
+    },
+    "express": {
+     "sample": 175,
+     "seconds": 23.0,
+     "units_per_s": 7.61,
+     "estimate_full_min": 0.38
+    },
+    "cli": {
+     "sample": 1000,
+     "seconds": 264.37,
+     "units_per_s": 3.78,
+     "estimate_full_min": 21.56
+    },
+    "pandas": {
+     "sample": 1000,
+     "seconds": 216.35,
+     "units_per_s": 4.62,
+     "estimate_full_min": 111.98
+    },
+    "cockroach": {
+     "sample": 1000,
+     "seconds": 219.04,
+     "units_per_s": 4.57,
+     "estimate_full_min": 293.22
+    }
+   }
+  },
+  "fp32-1024-8": {
+   "load_s": 2.59,
+   "rss_after_load_mib": 1861.2,
+   "peak_rss_mib": 3273.9,
+   "query_ms": {
+    "n": 50,
+    "p50": 62.0,
+    "p95": 63.3,
+    "max": 65.0
+   },
+   "repos": {
+    "fastapi": {
+     "sample": 1000,
+     "seconds": 199.98,
+     "units_per_s": 5.0,
+     "estimate_full_min": 15.28
+    },
+    "express": {
+     "sample": 175,
+     "seconds": 23.57,
+     "units_per_s": 7.42,
+     "estimate_full_min": 0.39
+    },
+    "cli": {
+     "sample": 1000,
+     "seconds": 387.2,
+     "units_per_s": 2.58,
+     "estimate_full_min": 31.58
+    },
+    "pandas": {
+     "sample": 1000,
+     "seconds": 259.51,
+     "units_per_s": 3.85,
+     "estimate_full_min": 134.32
+    },
+    "cockroach": {
+     "sample": 1000,
+     "seconds": 348.82,
+     "units_per_s": 2.87,
+     "estimate_full_min": 466.95
+    }
+   }
+  },
+  "int8-512-8": {
+   "load_s": 3.86,
+   "rss_after_load_mib": 1970.7,
+   "peak_rss_mib": 2205.1,
+   "query_ms": {
+    "n": 50,
+    "p50": 21.3,
+    "p95": 23.1,
+    "max": 24.4
+   },
+   "repos": {
+    "fastapi": {
+     "sample": 1000,
+     "seconds": 102.14,
+     "units_per_s": 9.79,
+     "estimate_full_min": 7.8
+    },
+    "express": {
+     "sample": 175,
+     "seconds": 15.82,
+     "units_per_s": 11.06,
+     "estimate_full_min": 0.26
+    },
+    "cli": {
+     "sample": 1000,
+     "seconds": 209.69,
+     "units_per_s": 4.77,
+     "estimate_full_min": 17.1
+    },
+    "pandas": {
+     "sample": 1000,
+     "seconds": 169.34,
+     "units_per_s": 5.91,
+     "estimate_full_min": 87.65
+    },
+    "cockroach": {
+     "sample": 1000,
+     "seconds": 168.22,
+     "units_per_s": 5.94,
+     "estimate_full_min": 225.19
+    }
+   }
+  }
+ },
+ "partial": {
+  "fp32-512-4": {
+   "note": "Stopped at the pod time limit after 3 of 5 repositories. It is not an 8-thread config, so the rule does not use it.",
+   "estimate_full_min": {
+    "fastapi": 18.46,
+    "express": 0.64,
+    "cli": 37.2
+   }
+  }
+ },
+ "int8_cosine": {
+  "fastapi": {
+   "mean": 0.834,
+   "p01": 0.7386
+  },
+  "express": {
+   "mean": 0.8231,
+   "p01": 0.7395
+  },
+  "cli": {
+   "mean": 0.7754,
+   "p01": 0.6676
+  },
+  "pandas": {
+   "mean": 0.817,
+   "p01": 0.7445
+  },
+  "cockroach": {
+   "mean": 0.7985,
+   "p01": 0.6934
+  }
+ },
+ "checks": {
+  "fp32-512-8": {
+   "query_p95_ms": 52.9,
+   "query_ok": true,
+   "median_repo": "cli",
+   "median_min": 21.56,
+   "median_ok": false,
+   "largest_repo": "cockroach",
+   "largest_min": 293.22,
+   "largest_ok": false,
+   "peak_rss_mib": 2107.4,
+   "rss_ok": false,
+   "pass": false
+  },
+  "fp32-1024-8": {
+   "query_p95_ms": 63.3,
+   "query_ok": true,
+   "median_repo": "cli",
+   "median_min": 31.58,
+   "median_ok": false,
+   "largest_repo": "cockroach",
+   "largest_min": 466.95,
+   "largest_ok": false,
+   "peak_rss_mib": 3273.9,
+   "rss_ok": false,
+   "pass": false
+  },
+  "int8-512-8": {
+   "query_p95_ms": 23.1,
+   "query_ok": true,
+   "median_repo": "cli",
+   "median_min": 17.1,
+   "median_ok": false,
+   "largest_repo": "cockroach",
+   "largest_min": 225.19,
+   "largest_ok": false,
+   "peak_rss_mib": 2205.1,
+   "rss_ok": false,
+   "cosine_mean": 0.8096,
+   "cosine_ok": false,
+   "pass": false
+  }
+ },
+ "estimate_check": {
+  "estimate_min": 21.56,
+  "actual_min": 20.57,
+  "ratio": 0.954,
+  "within_20pct": true,
+  "peak_rss_mib": 2054.2,
+  "units": 4893,
+  "seconds": 1234.1
+ },
+ "decision": "fail",
+ "speedup_needed_fp32_512_8": {
+  "median_repo_cli": 2.16,
+  "largest_repo_cockroach": 4.89
+ },
+ "run_order": [
+  "prepare",
+  "fp32-512-8",
+  "int8-512-8",
+  "fp32-1024-8 (stopped at 20:51:05Z, then run again)",
+  "full cli fp32-512-8",
+  "fp32-1024-8",
+  "fp32-512-4 (partial)",
+  "summary"
+ ],
+ "spend": {
+  "pod_minutes": 85.8,
+  "rate_usd_per_hour": 0.5,
+  "estimate_usd": 0.72,
+  "invoice_checked": false,
+  "pod_destroyed": "2026-10-19T21:46Z"
+ }
+}

attocode_code_intel-0.1.12/evals/results/2026-10-19-cpu-fn-embed-cost.md

@@ -0,0 +1,157 @@
+# CPU cost of function-unit embeddings (2026-10-19)
+
+**Status: fail. CodeRankEmbed over function units is too slow on 8 CPU
+threads for an opt-in product mode. The query time passes (p95 52.9 ms).
+The index time fails: 21.6 minutes for the median repository (limit 10)
+and 293 minutes for the largest (limit 60). Peak memory is 2,107 MiB
+(limit 2,048). A naive int8 model is only 1.25 times faster, and it
+changes the vectors (mean cosine 0.81 to fp32). One full index confirmed
+the estimates within 5 percent.**
+
+## The question
+
+On Loc-Bench 560, `fn-dense` (CodeRankEmbed over function units) gave
+0.739 Acc@5, against 0.566 for `product`
+([2026-10-18](2026-10-18-locbench-remeasure.md)). The function unit gives
++0.055 of that gain ([2026-10-19](2026-10-19-function-bm25.md)). That run
+used a GPU. This test asks whether a CPU can build and query the same
+index as an opt-in product mode. It measures cost only, not quality.
+
+## What we ran
+
+- **Code.** `main` at `94471b6`. The script is
+  `eval/matrix/function_embed_cost.py`.
+- **Model.** `nomic-ai/CodeRankEmbed` at revision `3c4b6080`, the revision
+  of `eval.matrix.dense`.
+- **Units.** Product discovery and product `parse_file`: every top-level
+  function and every class method, in all parsed languages. The units include
+  test files. The text of a unit is its relative path, a newline and its
+  source lines.
+- **Configs.** Weights, maximum tokens and CPU threads: `fp32-512-8`,
+  `int8-512-8`, `fp32-1024-8` and `fp32-512-4`. Each config runs in its own
+  process. The process pins itself to that many vCPUs before torch loads.
+  int8 uses `torch.ao.quantization.quantize_dynamic` on the linear layers.
+- **Measure.** 1,000 random units of each repository (all units if fewer),
+  batch 16. The seconds for each unit times the unit count give the full
+  index time. Query time is 50 workflow-pack queries, one at a time, after
+  5 warm-up calls. Memory is the peak RSS of the process.
+- **Computer.** One RunPod pod: AMD EPYC 7282 (Zen 2, AVX2), 64 visible
+  vCPUs, a cgroup quota of 13.6 CPUs. The pod had a GPU (RTX PRO 4500 SE),
+  but the test did not use it. torch 2.8.0, sentence-transformers 3.4.1.
+
+| Repository | Commit | Files | Units | Test units | Token p50 | Token p90 |
+| --- | --- | ---: | ---: | ---: | ---: | ---: |
+| express | `6c4249fe` | 158 | 175 | 30 | 73 | 205 |
+| fastapi | `11614be9` | 2,640 | 4,583 | 3,491 | 91 | 264 |
+| cli | `6e49747f` | 904 | 4,893 | 1,659 | 180 | 817 |
+| pandas | `0039f168` | 1,658 | 31,056 | 20,979 | 148 | 415 |
+| cockroach | `53aadff3` | 8,462 | 80,319 | 7,727 | 103 | 576 |
+
+By unit count, `cli` is the median repository and `cockroach` is the
+largest.
+
+## Frozen rule
+
+We wrote the rule before the pod started
+([design](../designs/2026-10-19-cpu-fn-embed-cost.json)). The test passes
+if at least one 8-thread config meets all of these limits:
+
+1. Query p95 ≤ 150 ms.
+2. Estimated full index ≤ 10 minutes for the median repository.
+3. Estimated full index ≤ 60 minutes for the largest repository.
+4. Peak RSS ≤ 2 GiB.
+5. For int8: a mean cosine to fp32 of at least 0.99.
+
+One full index of `cli` with `fp32-512-8` must fall within 20 percent of
+its estimate. Otherwise every estimate is unreliable.
+
+## Results
+
+| Config | Query p95 | cli | cockroach | Peak RSS | int8 cosine | Pass |
+| --- | ---: | ---: | ---: | ---: | ---: | --- |
+| `fp32-512-8` | 52.9 ms | 21.56 min | 293.22 min | 2,107 MiB | | no |
+| `int8-512-8` | 23.1 ms | 17.10 min | 225.19 min | 2,205 MiB | 0.810 | no |
+| `fp32-1024-8` | 63.3 ms | 31.58 min | 466.95 min | 3,274 MiB | | no |
+
+Only the query limit passes, in all three configs. Estimated full index
+times for the other repositories with
+`fp32-512-8`: express 0.38 minutes, fastapi 9.32, pandas 111.98.
+
+- **Estimate check.** The full `cli` index took 20.57 minutes for 4,893
+  units, against an estimate of 21.56 minutes (ratio 0.954). The estimates
+  are reliable.
+- **Throughput.** `fp32-512-8` encodes 3.8 to 8.2 units per second. Go
+  units in `cli` are the longest, and they are the slowest.
+- **Memory.** The model alone needs 1,883 MiB after it loads, before it
+  encodes a unit.
+- **int8.** Per repository, the mean cosine to fp32 is 0.78 to 0.83. This
+  quantization method changes the vectors too much to keep the quality of
+  the fp32 model.
+- **Gap.** To meet the limits, `fp32-512-8` must be 2.2 times faster for
+  `cli` and 4.9 times faster for `cockroach`.
+
+## Changes during the run
+
+The rule did not change. The run order did:
+
+1. The planned order was the four configs, then the full `cli` check. The
+   pod had a time limit, so the check moved forward.
+2. After `int8-512-8` finished (20:51:05Z), the operator stopped
+   `fp32-1024-8` and started the full check. `fp32-1024-8` then ran again
+   from the start.
+3. `fp32-512-4` stopped at the time limit after 3 of 5 repositories. Its
+   partial `cli` estimate is 37.2 minutes. The rule uses only 8-thread
+   configs, so this partial result does not change the decision.
+
+The script reads only the cgroup v2 quota. The pod used cgroup v1, so the
+JSON records the quota as null. We read the 13.6-CPU quota by hand.
+
+## Limits
+
+- **One older CPU.** Zen 2 is from 2019 and has no AVX-512 VNNI or AMX.
+  A newer server CPU can be faster. Apple Silicon with MPS was not
+  measured.
+- **One int8 method.** Dynamic quantization of the linear layers only.
+  ONNX Runtime or OpenVINO int8 can keep more quality. They were not
+  tested.
+- **No shorter units.** A cap of 256 tokens was not tested.
+- **No quality.** The test measures cost only.
+- **express.** The JavaScript parser makes no unit from a function that
+  the code assigns to a property (`res.send = function ...`). Thus express
+  has only 175 units. It is the smallest repository, so this does not
+  change the median or the largest.
+
+## What this means
+
+A full CPU index of function units is not a product option on this class
+of hardware. The query side is cheap, but the index side is 2 to 5 times
+too slow. Encoding only a short candidate list at query time is not cheap
+either: at 4 to 8 units per second, 24 candidates take about 3 to 6
+seconds. This estimate comes from the throughput above, not from a
+measurement. A useful function-unit embedding needs a GPU or a remote
+service.
+
+## Reproduce
+
+On a Linux x86 host with this repository at `94471b6` and the model
+installed:
+
+1. Run `python eval/matrix/function_embed_cost.py prepare WORK CODE`.
+2. For each config, run
+   `python eval/matrix/function_embed_cost.py encode WORK CODE CONFIG`.
+3. Run `python eval/matrix/function_embed_cost.py full WORK CODE cli fp32-512-8`.
+4. Run `python eval/matrix/function_embed_cost.py summary WORK`.
+
+## Spend
+
+The pod ran 85.8 minutes at $0.50 an hour, about $0.72. This is an
+estimate. We did not check the invoice. We destroyed the pod at 21:46Z,
+and the fleet then had no nodes.
+
+## Artifacts
+
+- [Design](../designs/2026-10-19-cpu-fn-embed-cost.json): the frozen rule.
+- [Summary](2026-10-19-cpu-fn-embed-cost.json): the units, every config,
+  the checks, the estimate check, the int8 cosines, the run order, the
+  spend and the SHA-256 of the frozen script.
+- The logs and the per-config result files stay private.

{attocode_code_intel-0.1.11 → attocode_code_intel-0.1.12}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "attocode-code-intel"
-version = "0.1.11"
+version = "0.1.12"
 description = "Local code search and navigation for coding agents and people"
 readme = "README.md"
 requires-python = ">=3.12"

{attocode_code_intel-0.1.11 → attocode_code_intel-0.1.12}/src/attocode_intel/__init__.py

@@ -49,4 +49,4 @@ def __getattr__(name: str) -> Any:
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 # The other copy is packages/code-intel/pyproject.toml. A test checks that both match.
-__version__ = "0.1.11"
+__version__ = "0.1.12"

{attocode_code_intel-0.1.11 → attocode_code_intel-0.1.12}/src/attocode_intel/onboarding.py

@@ -204,6 +204,14 @@ async def diagnose(client, project=".", *, global_scope=False, remote=False):
     text = config.read_text() if config.exists() else ""
     doc = (tomlkit.parse(text) if config.suffix == ".toml" else json.loads(text)) if text else {}
     entry = doc.get(key, {}).get(name)
+    if client == "claude" and not global_scope:
+        # `claude mcp add` uses local scope by default: ~/.claude.json, under the project path.
+        # Claude Code prefers a local entry to a project entry with the same name.
+        home_config = Path.home() / ".claude.json"
+        home = json.loads(home_config.read_text()) if home_config.exists() else {}
+        local = home.get("projects", {}).get(str(root), {}).get(key, {}).get(name)
+        if local:
+            config, entry = home_config, local
     if not entry:
         return {"client": client, "status": "not configured", "config": str(config),
                 "hint": f"Run: attocode-code-intel init --client {client}"}
@@ -231,6 +239,7 @@ async def diagnose(client, project=".", *, global_scope=False, remote=False):
                 raise RuntimeError("Bounded project query failed")
             return {
                 "client": client,
+                "config": str(config),
                 "tools": len(catalog.tools),
                 "metadata": metadata,
                 "status": "ok",

{attocode_code_intel-0.1.11 → attocode_code_intel-0.1.12}/tests/test_doctor.py

@@ -25,6 +25,26 @@ async def test_doctor_reports_a_client_without_configuration(tmp_path):
     assert "init --client claude" in result["hint"]
 
 
+@pytest.mark.asyncio
+async def test_doctor_reads_claude_local_scope_first(tmp_path, monkeypatch):
+    import json
+
+    project, home = tmp_path / "project", tmp_path / "home"
+    project.mkdir()
+    home.mkdir()
+    (project / "main.py").write_text("def example(): return 1\n")
+    monkeypatch.setenv("HOME", str(home))
+    entry = configure_client("claude", project, dry_run=True)["configuration"]
+    # `claude mcp add` (local scope) writes here; a broken project entry must not hide it.
+    (home / ".claude.json").write_text(json.dumps(
+        {"projects": {str(project.resolve()): {"mcpServers": {"attocode-code-intel": entry}}}}))
+    (project / ".mcp.json").write_text(json.dumps(
+        {"mcpServers": {"attocode-code-intel": {"command": str(tmp_path / "missing")}}}))
+    result = await diagnose("claude", project)
+    assert result["status"] == "ok"
+    assert result["config"] == str(home / ".claude.json")
+
+
 def test_doctor_for_all_clients_fails_only_when_none_is_ready(tmp_path, capsys):
     from attocode_intel import entrypoint