From c317b91a263d7d654102b181b304b20ff969ff32 Mon Sep 17 00:00:00 2001 From: Ronald Lokers Date: Fri, 6 Nov 2026 15:52:58 +0100 Subject: [PATCH] chore(deps): consolidate dependency updates --- .chezmoiversion | 2 +- .github/renovate.json | 4 +- .github/workflows/ci.yaml | 4 +- .github/workflows/renovate.yaml | 2 +- home/.chezmoiexternals/mise.toml | 4 +- home/.chezmoiexternals/pure.toml | 4 +- home/dot_claude/skills/graphify/SKILL.md | 113 +++++++++++++++--- .../skills/graphify/dot_graphify_version | 2 +- .../skills/graphify/references/add-watch.md | 4 +- .../skills/graphify/references/exports.md | 14 ++- .../graphify/references/extraction-spec.md | 20 +++- .../skills/graphify/references/hooks.md | 15 +++ .../skills/graphify/references/query.md | 22 ++-- .../skills/graphify/references/update.md | 35 ++++-- home/dot_config/mise/config.toml.tmpl | 57 ++++----- mise.toml | 4 +- 16 files changed, 225 insertions(+), 81 deletions(-) diff --git a/.chezmoiversion b/.chezmoiversion index af4fa19..04b6fa2 100644 --- a/.chezmoiversion +++ b/.chezmoiversion @@ -1 +1 @@ -2.72.1 +2.74.0 diff --git a/.github/renovate.json b/.github/renovate.json index e1bf7a4..8a7e7f8 100644 --- a/.github/renovate.json +++ b/.github/renovate.json @@ -5,7 +5,7 @@ ], "mise": { "managerFilePatterns": [ - "/(^|/)dot_config/mise/config\\.toml$/", + "/(^|/)dot_config/mise/config\\.toml(?:\\.tmpl)?$/", "/(^|/)mise\\.toml$/" ] }, @@ -76,7 +76,7 @@ { "description": "Never automerge the mise tool lists. Same reasoning as the externals rule below, and it was inconsistent to apply it to one and not the other: home/dot_config/mise/config.toml installs and runs the CLI tools this machine uses all day, and mise.toml installs the linters and the test runner that this repo's own checks execute. Both are code that runs as you, fetched from upstream, with CI asserting only that the install succeeded \u2014 never that the contents are what was expected. A green pipeline says the new version installs, not that it is the version the maintainer published. The cost is a PR to click rather than one to read; the alternative is a compromised release reaching every machine's next apply with nobody having looked.", "matchFileNames": [ - "home/dot_config/mise/config.toml", + "home/dot_config/mise/config.toml.tmpl", "mise.toml" ], "automerge": false diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index d4f4ab1..57cb6cc 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -23,7 +23,7 @@ jobs: # --yes` renovate, so "CI is green" said nothing about which versions a # contributor had locally — the validator in particular passed here and # failed on a developer machine with a stale npx cache. - - uses: jdx/mise-action@c2a87611a18de5b3828c5652fe268e992400cb5c # v4.3.0 + - uses: jdx/mise-action@f5be966e4a917d54244728e6a5fdcd1d93a35e6c # v5.2.6 - name: lint run: mise run lint @@ -33,7 +33,7 @@ jobs: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7 # Same reasoning as the lint job: the suite and the bats that runs it are # both pinned in mise.toml, so a local run and this one are identical. - - uses: jdx/mise-action@c2a87611a18de5b3828c5652fe268e992400cb5c # v4.3.0 + - uses: jdx/mise-action@f5be966e4a917d54244728e6a5fdcd1d93a35e6c # v5.2.6 - name: test run: mise run test diff --git a/.github/workflows/renovate.yaml b/.github/workflows/renovate.yaml index 0a07c45..316e0f1 100644 --- a/.github/workflows/renovate.yaml +++ b/.github/workflows/renovate.yaml @@ -16,7 +16,7 @@ jobs: runs-on: ubuntu-latest steps: - name: Run Renovate - uses: renovatebot/github-action@f0f41e5f2e706165f6814b1d0f0d0e319de7d1d9 # v46.3.8 + uses: renovatebot/github-action@1c0cf989c02653fba0efe7ca5772338860ca71dc # v46.3.12 with: token: ${{ secrets.RENOVATE_TOKEN }} env: diff --git a/home/.chezmoiexternals/mise.toml b/home/.chezmoiexternals/mise.toml index 70471c9..91e6fd5 100644 --- a/home/.chezmoiexternals/mise.toml +++ b/home/.chezmoiexternals/mise.toml @@ -1,4 +1,4 @@ -{{- $miseVersion := "v2026.9.1" -}} +{{- $miseVersion := "v2026.11.3" -}} # mise binary, pinned to an immutable release asset (linux-x64). Renovate bumps # $miseVersion via the custom manager in .github/renovate.json. # @@ -16,5 +16,5 @@ type = "file" executable = true url = "https://github.com/jdx/mise/releases/download/{{ $miseVersion }}/mise-{{ $miseVersion }}-linux-x64" -checksum.sha256 = "c98423c8470d6dc416d9f7036d0646d8ef5ae92ad9186907f8fcc84cbe7db4ea" +checksum.sha256 = "c2f7e814cb39f60b7f67a0ff36cb805e94128bf2dff09d175309d0f095b8cc3b" refreshPeriod = "168h" diff --git a/home/.chezmoiexternals/pure.toml b/home/.chezmoiexternals/pure.toml index 10679e5..73cf030 100644 --- a/home/.chezmoiexternals/pure.toml +++ b/home/.chezmoiexternals/pure.toml @@ -15,10 +15,10 @@ # Renovate cannot update these lines, so a version bump that leaves one stale # fails the apply. Bump version and hash together. # renovate: datasource=github-tags depName=sindresorhus/pure -{{ $pureVersion := "v1.28.3" }} +{{ $pureVersion := "v1.28.4" }} [".zsh/pure"] type = "archive" url = "https://github.com/sindresorhus/pure/archive/refs/tags/{{ $pureVersion }}.tar.gz" -checksum.sha256 = "738b523c59823083de490b3eb6c1116fc45c342e6b32a7d3cf05fdd0f8aa75a8" +checksum.sha256 = "76cdc22defa2c1f5f4b257b8944be8ee5795ff34feaa0e8a2dc8ea8278c7d63b" stripComponents = 1 refreshPeriod = "168h" diff --git a/home/dot_claude/skills/graphify/SKILL.md b/home/dot_claude/skills/graphify/SKILL.md index abd2811..8c23326 100644 --- a/home/dot_claude/skills/graphify/SKILL.md +++ b/home/dot_claude/skills/graphify/SKILL.md @@ -17,6 +17,7 @@ Turn any folder of files into a navigable knowledge graph with community detecti /graphify ... # clone multiple repos, build each, merge into one cross-repo graph /graphify --mode deep # thorough extraction, richer INFERRED edges /graphify --update # incremental - re-extract only new/changed files +/graphify --force # full rebuild allowing graph shrink (e.g. after deleting files) /graphify --directed # build directed graph (preserves edge direction: source→target) /graphify --whisper-model medium # use a larger Whisper model for better transcription accuracy /graphify --cluster-only # rerun clustering on existing graph @@ -46,6 +47,10 @@ Turn any folder of files into a navigable knowledge graph with community detecti Drop any folder of code, docs, papers, images, or video into graphify and get a queryable knowledge graph. Persistent across sessions, honest audit trail (EXTRACTED/INFERRED/AMBIGUOUS), community detection surfaces cross-document connections you wouldn't think to ask about. +**When a graph is worth building:** this applies when you are choosing a tool yourself; if the user invoked `/graphify`, follow that request as asked. AST extraction of code is fast and free, but semantic extraction of docs, papers and images runs the model over every file, which can cost minutes and tens of thousands of tokens. + +If a graph already exists, query it. With no graph, one targeted lookup ("where is X defined", "what calls Y" in an ordinary-sized codebase) is faster and free with a plain text search such as `grep` and `Read`: search directly instead of running the steps below, and mention that a graph can be built if the user wants one. Build one when you expect many questions against this corpus, the corpus is large or unfamiliar, the question needs links text search cannot see (doc to code, across documents), or it is structural (communities, bridges, import cycles). + ## What You Must Do When Invoked If the user invoked `/graphify --help` or `/graphify -h` (with no other arguments), print the contents of the `## Usage` section above verbatim and stop. Do not run any commands, do not detect files, do not default the path to `.`. Just print the Usage block and return. @@ -56,7 +61,7 @@ If no path was given, use `.` (current directory). Do not ask the user for a pat If the path argument starts with `https://github.com/` or `http://github.com/`, treat it as a GitHub URL - run Step 0 before anything else, then continue with the resolved local path. -Follow these steps in order. Do not skip steps. +Follow these steps in order unless the fast path above applies. ### Step 0 - GitHub repos and multi-path merge (only if a URL or several paths) @@ -96,8 +101,14 @@ fi # Write interpreter path for all subsequent steps (persists across invocations) mkdir -p graphify-out "$PYTHON" -c "import sys; open('graphify-out/.graphify_python', 'w', encoding='utf-8').write(sys.executable)" -# Save scan root so `graphify update` (no args) knows where to look next time -echo "$(cd INPUT_PATH && pwd)" > graphify-out/.graphify_root +# Save scan root so `graphify update` (no args) knows where to look next time. +# The scan path is passed through a quoted heredoc, never substituted into the +# command line itself: a bare `cd ` (or an unquoted heredoc, which +# still expands $()/backticks in its body) would let a malicious path execute +# as shell code the moment this line runs. +"$PYTHON" -c "import os, sys; out_path = os.path.abspath('graphify-out/.graphify_root'); os.chdir(sys.stdin.readline().rstrip('\n')); open(out_path, 'w', encoding='utf-8').write(os.getcwd())" <<'GRAPHIFY_ROOT_EOF' +INPUT_PATH +GRAPHIFY_ROOT_EOF ``` If the import succeeds, print nothing and move straight to Step 2. @@ -111,7 +122,9 @@ $(cat graphify-out/.graphify_python) -c " import json from graphify.detect import detect from pathlib import Path -result = detect(Path('INPUT_PATH')) +from graphify.paths import out_path +from graphify.watch import _read_build_excludes, _read_build_gitignore +result = detect(Path('INPUT_PATH'), extra_excludes=_read_build_excludes(out_path()), gitignore=_read_build_gitignore(out_path())) # Write the sidecar from Python, not a shell redirect, so the same block renders # on PowerShell hosts without console-encoding drift (#2528). Path('graphify-out/.graphify_detect.json').write_text(json.dumps(result, ensure_ascii=False), encoding=\"utf-8\") @@ -184,7 +197,10 @@ for f in detect.get('files', {}).get('code', []): code_files.extend(collect_files(Path(f)) if Path(f).is_dir() else [Path(f)]) if code_files: - result = extract(code_files, cache_root=Path('INPUT_PATH')) + # root= anchors node ids and source_file on the scan root; cache_root only says + # where graphify-out/cache lives. Pass both: without root= the anchor falls back + # to cache_root, so pointing the cache elsewhere would rename every node (#3727). + result = extract(code_files, cache_root=Path('INPUT_PATH'), root=Path('INPUT_PATH')) Path('graphify-out/.graphify_ast.json').write_text(json.dumps(result, indent=2, ensure_ascii=False), encoding=\"utf-8\") print(f'AST: {len(result[\"nodes\"])} nodes, {len(result[\"edges\"])} edges') else: @@ -209,7 +225,7 @@ Path('graphify-out/.graphify_semantic.json').write_text(json.dumps({'nodes':[],' Before dispatching subagents, print a timing estimate: - Load `total_words` and file counts from `graphify-out/.graphify_detect.json` -- Estimate agents needed: `ceil(uncached_non_code_files / 22)` (chunk size is 20-25) +- Estimate agents needed: `ceil(uncached_non_code_files / 22)` (chunk size is 20-25 files, capped at ~6000 total lines) - Estimate time: ~45s per agent batch (they run in parallel, so total ≈ 45s × ceil(agents/parallel_limit)) - Print: "Semantic extraction: ~N files → X agents, estimated ~Ys" @@ -240,15 +256,21 @@ if cached_nodes or cached_edges or cached_hyperedges: else: Path('graphify-out/.graphify_cached.json').unlink(missing_ok=True) Path('graphify-out/.graphify_uncached.txt').write_text('\n'.join(uncached), encoding=\"utf-8\") +# Nothing has been dispatched yet, so any chunk file on disk is a leftover from an +# interrupted run, and Step B3 merges every .graphify_chunk_*.json it finds. +for stale in Path('graphify-out').glob('.graphify_chunk_*.json'): + stale.unlink() print(f'Cache: {len(all_files)-len(uncached)} files hit, {len(uncached)} files need extraction') " ``` -Only dispatch subagents for files listed in `graphify-out/.graphify_uncached.txt`. If all files are cached, skip to Part C directly. +Only dispatch subagents for files listed in `graphify-out/.graphify_uncached.txt`. If all files are cached, skip Steps B1 and B2 but still run Step B3's commands: its merge is the only Part B step that writes `graphify-out/.graphify_semantic.json`, and Part C reads that file unconditionally. Do not write an empty `.graphify_semantic.json` instead, because that drops every cached node. **Step B1 - Split into chunks** -Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks of 20-25 files each. Each image gets its own chunk (vision needs separate context). When splitting, group files from the same directory together so related artifacts land in the same chunk and cross-file relationships are more likely to be extracted. +Load files from `graphify-out/.graphify_uncached.txt`. Split into chunks bounded by BOTH limits: at most 20-25 files AND at most ~6000 total lines per chunk. A text file longer than 2000 lines gets a chunk to itself - that is past the Read tool's single-call cap, so sharing a chunk with other files guarantees it is only partly read. Each image gets its own chunk (vision needs separate context). When splitting, group files from the same directory together so related artifacts land in the same chunk and cross-file relationships are more likely to be extracted. + +Both bounds matter. The line bound is not only about the 2000-line Read cap: a subagent holding 25 files splits its attention across all of them and skims the dense ones, and a 590-line plan can come back with zero nodes that way. Bounding content as well as file count is what keeps a chunk's coverage honest (#2225). **Step B2 - Dispatch ALL subagents in a single message** @@ -286,6 +308,44 @@ Wait for all subagents. For each result: If more than half the chunks failed or are missing, stop and tell the user to re-run and ensure `subagent_type="general-purpose"` is used. +**Step B3.5 - Verify each reported file was actually read to its end** + +A subagent that only read the first Read call's worth of a long file still writes a well-formed chunk, so "chunk file exists and parses" is not evidence of coverage. Compare each file's self-reported `coverage` against its real length: + +```bash +$(cat graphify-out/.graphify_python) -c " +import json, glob +from pathlib import Path + +covered = {} +for c in sorted(glob.glob('graphify-out/.graphify_chunk_*.json')): + d = json.loads(Path(c).read_text(encoding=\"utf-8\")) + for src, n in (d.get('coverage') or {}).items(): + covered[src] = max(covered.get(src, 0), int(n)) + +partial = [] +for src, n in sorted(covered.items()): + p = Path(src) + if not p.is_absolute(): + p = Path('INPUT_PATH') / src + if not p.is_file(): + continue + total = sum(1 for _ in p.open(encoding='utf-8', errors='replace')) + if total and n < total: + partial.append((src, n, total)) + +Path('graphify-out/.graphify_partial.txt').write_text('\n'.join(s for s, _, _ in partial), encoding=\"utf-8\") +if partial: + print(f'WARNING: {len(partial)} file(s) were only partly read. They are cached as partial and retried on the next --update:') + for src, n, total in partial: + print(f' {src}: read {n} of {total} lines') +else: + print('Coverage OK - every file a subagent reported was read to its last line') +" +``` + +Tell the user which files came up short and what was lost (the line counts are printed above). The nodes already extracted for those files are kept - they are still true - but the file is cached as partial and left unstamped in the manifest below, so the next `--update` re-dispatches it and replace-on-re-extract swaps the partial node set for a complete one. This is the same mechanism the library path uses for a truncated LLM response (#933, #1950), so both paths now recover instead of silently keeping a half-read file forever. A file a subagent did not report at all is not counted as partial - there is nothing to compare against - which is why the prompt rule in `references/extraction-spec.md` asks for the count in the first place. + Merge all chunk files into `.graphify_semantic_new.json`. **After each Agent call completes, read the real token counts from the Agent tool result's `usage` field and write them back into the chunk JSON before merging** — the chunk JSON itself always has placeholder zeros. Then run: ```bash $(cat graphify-out/.graphify_python) -c " @@ -319,8 +379,13 @@ from pathlib import Path new = json.loads(Path('graphify-out/.graphify_semantic_new.json').read_text(encoding=\"utf-8\")) if Path('graphify-out/.graphify_semantic_new.json').exists() else {'nodes':[],'edges':[],'hyperedges':[]} uncached = [line for line in Path('graphify-out/.graphify_uncached.txt').read_text(encoding=\"utf-8\").splitlines() if line] -saved = save_semantic_cache(new.get('nodes', []), new.get('edges', []), new.get('hyperedges', []), root='INPUT_PATH', allowed_source_files=uncached, prompt_file='SPEC_PATH') -print(f'Cached {saved} files') +# A partly-read file is cached with partial: True, which load_cached treats as a MISS, +# so the next --update re-dispatches it instead of serving a truncated extraction forever +# (#2225). Same contract the library path uses for a truncated LLM response (#933/#1950). +partial = [line for line in Path('graphify-out/.graphify_partial.txt').read_text(encoding=\"utf-8\").splitlines() if line] if Path('graphify-out/.graphify_partial.txt').exists() else [] +saved = save_semantic_cache(new.get('nodes', []), new.get('edges', []), new.get('hyperedges', []), root='INPUT_PATH', allowed_source_files=uncached, prompt_file='SPEC_PATH', partial_source_files=partial) +note = f' ({len(partial)} left partial for retry)' if partial else '' +print(f'Cached {saved} files' + note) " ``` @@ -366,6 +431,18 @@ from pathlib import Path ast = json.loads(Path('graphify-out/.graphify_ast.json').read_text(encoding=\"utf-8\")) sem = json.loads(Path('graphify-out/.graphify_semantic.json').read_text(encoding=\"utf-8\")) +# Stamp tier provenance on the semantic side. build._is_ast_tier reads +# _origin when present and otherwise guesses from the SHAPE of +# source_location ('L' means AST). A subagent that writes 'L12' for a +# doc section therefore made that node read as AST, and the next +# graphify update deleted it along with the re-extracted code file it +# seemed to belong to (#2843). extract() stamps its own items 'ast'; the +# semantic side must say so explicitly. +for n in sem['nodes']: + n.setdefault('_origin', 'semantic') +for e in sem['edges']: + e.setdefault('_origin', 'semantic') + # Merge: AST nodes first, semantic nodes deduplicated by id seen = {n['id'] for n in ast['nodes']} merged_nodes = list(ast['nodes']) @@ -392,7 +469,7 @@ print(f'Merged: {total} nodes, {edges} edges ({len(ast[\"nodes\"])} AST + {len(s ### Step 4 - Build graph, cluster, analyze, generate outputs -**Before starting:** the code blocks below pass `directed=IS_DIRECTED` to `build_from_json()`. Replace `IS_DIRECTED` with `True` if `--directed` was given (builds a `DiGraph` preserving edge direction source→target), otherwise `False` (the default undirected `Graph`). Substitute it the same way you substitute `INPUT_PATH` — do not leave the literal `IS_DIRECTED` in the code. +**Before starting:** the code blocks below pass `directed=IS_DIRECTED` to `build_from_json()` and `force=IS_FORCE` to `to_json()`. Replace `IS_DIRECTED` with `True` if `--directed` was given (builds a `DiGraph` preserving edge direction source→target), otherwise `False` (the default undirected `Graph`). Replace `IS_FORCE` with `True` if `--force` was given (permits intentional shrink, e.g. after deleting files), otherwise `False`. Substitute them the same way you substitute `INPUT_PATH` — do not leave literal `IS_DIRECTED` or `IS_FORCE` in the code. ```bash mkdir -p graphify-out @@ -430,7 +507,7 @@ questions = suggest_questions(G, communities, labels) # nothing) when the new graph is smaller than the existing graph.json. Only write # GRAPH_REPORT.md + the analysis sidecar when the graph was actually written, so # they never describe a graph that graph.json doesn't contain (#1392). -wrote = to_json(G, communities, 'graphify-out/graph.json') +wrote = to_json(G, communities, 'graphify-out/graph.json', force=IS_FORCE) if not wrote: print('ERROR: refused to shrink graphify-out/graph.json (existing graph has more nodes; #479).') print('If this shrink is intentional (you deleted files), re-run a full build with --force.') @@ -581,7 +658,13 @@ extract = json.loads(Path('graphify-out/.graphify_extract.json').read_text(encod # types are gated on output. from graphify.cli import _stamped_manifest_files _corpus = detect.get('all_files') or detect['files'] -_manifest_files = _stamped_manifest_files(_corpus, extract, Path('INPUT_PATH')) +# A file a subagent only partly read DID produce output, so the stamp filter alone would +# keep it - but its node set covers just the head of the file, and stamping it means +# detect_incremental reads it as done and never re-queues it, leaving the truncated graph +# live forever. Name those files so they stay unstamped and are retried next run (#2225). +_pf = Path('graphify-out/.graphify_partial.txt') +_partial = {l.strip() for l in _pf.read_text(encoding=\"utf-8\").splitlines() if l.strip()} if _pf.exists() else set() +_manifest_files = _stamped_manifest_files(_corpus, extract, Path('INPUT_PATH'), partial_source_files=_partial) # Files dispatched this run (the changed subset) but NOT stamped above still carry # a stale semantic_hash from a prior run; clear it so detect_incremental re-queues # them instead of reading them as unchanged (#1948). @@ -618,7 +701,7 @@ cost_path.write_text(json.dumps(cost, indent=2, ensure_ascii=False), encoding=\" print(f'This run: {input_tok:,} input tokens, {output_tok:,} output tokens') print(f'All time: {cost[\"total_input_tokens\"]:,} input, {cost[\"total_output_tokens\"]:,} output ({len(cost[\"runs\"])} runs)') " -rm -f graphify-out/.graphify_detect.json graphify-out/.graphify_extract.json graphify-out/.graphify_ast.json graphify-out/.graphify_semantic.json graphify-out/.graphify_analysis.json +rm -f graphify-out/.graphify_detect.json graphify-out/.graphify_extract.json graphify-out/.graphify_ast.json graphify-out/.graphify_semantic.json graphify-out/.graphify_analysis.json graphify-out/.graphify_partial.txt find graphify-out -maxdepth 1 -name '.graphify_chunk_*.json' -delete 2>/dev/null rm -f graphify-out/.needs_update 2>/dev/null || true ``` @@ -639,6 +722,8 @@ If graphify saved you time, consider supporting it: https://github.com/sponsors/ Replace PATH_TO_DIR with the actual absolute path of the directory that was processed. +If PATH_TO_DIR is inside a git repository, add one line to the report: `graphify-out/` was written into the working tree, so unless the repository already ignores it, it will show in `git status`; the user can add `graphify-out/` to `.gitignore`, or commit only the outputs their team should share (see https://docs.graphify.com/guides/team-workflows). + Then paste these sections from GRAPH_REPORT.md directly into the chat: - God Nodes - Surprising Connections diff --git a/home/dot_claude/skills/graphify/dot_graphify_version b/home/dot_claude/skills/graphify/dot_graphify_version index c800671..df9d20d 100644 --- a/home/dot_claude/skills/graphify/dot_graphify_version +++ b/home/dot_claude/skills/graphify/dot_graphify_version @@ -1 +1 @@ -0.9.53 \ No newline at end of file +0.9.102 \ No newline at end of file diff --git a/home/dot_claude/skills/graphify/references/add-watch.md b/home/dot_claude/skills/graphify/references/add-watch.md index 7784434..349f8b4 100644 --- a/home/dot_claude/skills/graphify/references/add-watch.md +++ b/home/dot_claude/skills/graphify/references/add-watch.md @@ -41,10 +41,10 @@ Supported URL types (auto-detected): Start a background watcher that monitors a folder and auto-updates the graph when files change. ```bash -$(cat graphify-out/.graphify_python) -m graphify.watch INPUT_PATH --debounce 3 +$(cat graphify-out/.graphify_python) -m graphify.watch "$(cat graphify-out/.graphify_root)" --debounce 3 ``` -Replace INPUT_PATH with the folder to watch. Behavior depends on what changed: +This watches the same folder graphify extracted, read from the trusted `graphify-out/.graphify_root` that Step 1 resolved - there is no path to substitute, so a scan root containing shell metacharacters can never be re-interpreted here. Behavior depends on what changed: - **Code files only (.py, .ts, .go, etc.):** re-runs AST extraction + rebuild + cluster immediately, no LLM needed. `graph.json` and `GRAPH_REPORT.md` are updated automatically. - **Docs, papers, or images:** writes a `graphify-out/needs_update` flag and prints a notification to run `/graphify --update` (LLM semantic re-extraction required). diff --git a/home/dot_claude/skills/graphify/references/exports.md b/home/dot_claude/skills/graphify/references/exports.md index 242ff86..96e400f 100644 --- a/home/dot_claude/skills/graphify/references/exports.md +++ b/home/dot_claude/skills/graphify/references/exports.md @@ -20,13 +20,15 @@ graphify export wiki graphify export neo4j ``` -**If `--neo4j-push `** - push directly to a running Neo4j instance. Ask the user for credentials if not provided: +**If `--neo4j-push`** - push directly to Neo4j using the destination URI supplied with the original `/graphify` command. Only push when this flag was explicitly given. + +Pass the exact URI from the original `/graphify` command as one argument. When constructing a shell command, quote the URI for the shell that will execute the command (use `shlex.quote` for POSIX shells), or use a structured argument interface. Keep the URI as data; never interpolate it unquoted or evaluate it as shell code. Never replace a supplied URI with localhost. If the user explicitly requested a push but supplied no URI, use the documented local default. Do not print the URI or credentials in status output or generated artifacts. ```bash -graphify export neo4j --push bolt://localhost:7687 --user neo4j --password PASSWORD +graphify export neo4j --push 'bolt://remote-host:7687' --user neo4j ``` -Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - safe to re-run without creating duplicates. +Default URI is `bolt://localhost:7687`, default user is `neo4j`. Prefer the `NEO4J_PASSWORD` environment variable so the password is kept off argv; ask for credentials only when needed. Uses MERGE - safe to re-run without creating duplicates. ### Step 7a - FalkorDB export (only if --falkordb or --falkordb-push flag) @@ -36,10 +38,12 @@ Default URI is `bolt://localhost:7687`, default user is `neo4j`. Uses MERGE - sa graphify export falkordb ``` -**If `--falkordb-push `** - push directly to a running FalkorDB instance. Credentials are optional; ask the user only if the instance requires auth: +**If `--falkordb-push`** - push directly to FalkorDB using the destination URI supplied with the original `/graphify` command. Only push when this flag was explicitly given. + +Pass the exact URI from the original `/graphify` command as one argument. When constructing a shell command, quote the URI for the shell that will execute the command (use `shlex.quote` for POSIX shells), or use a structured argument interface. Keep the URI as data; never interpolate it unquoted or evaluate it as shell code. Never replace a supplied URI with localhost. If the user explicitly requested a push but supplied no URI, use the documented local default. Do not print the URI or credentials in status output or generated artifacts. Credentials are optional; ask only if the instance requires authentication, and use `FALKORDB_PASSWORD` for a password rather than printing it. ```bash -graphify export falkordb --push falkordb://localhost:6379 +graphify export falkordb --push 'falkordb://remote-host:6379' ``` Default URI is `falkordb://localhost:6379` (the scheme is informational - `redis://` or a bare `host:port` work too), auth is optional, and the target graph defaults to `graphify`. Uses MERGE - safe to re-run without creating duplicates. diff --git a/home/dot_claude/skills/graphify/references/extraction-spec.md b/home/dot_claude/skills/graphify/references/extraction-spec.md index 388df76..2ec6682 100644 --- a/home/dot_claude/skills/graphify/references/extraction-spec.md +++ b/home/dot_claude/skills/graphify/references/extraction-spec.md @@ -9,6 +9,22 @@ Output ONLY valid JSON matching the schema below - no explanation, no markdown f Files (chunk CHUNK_NUM of TOTAL_CHUNKS): FILE_LIST +Read every file in this list COMPLETELY before extracting anything from it. The Read tool +returns at most 2000 lines per call and reports NO error and NO warning when it truncates, so a +long file silently yields a partial extraction. When a file is longer than one call, keep paging +with offset/limit until you have actually seen its last line - never assume the first call +returned the whole file. Never emit nodes for a file you have only partly read. A partial +extraction is worse than none: replace-on-re-extract first DROPS that file's existing nodes and +then re-adds only what you saw, so the unread tail disappears from the graph, and the file is then +recorded as successfully extracted and never retried (#2225). + +Report the coverage you actually achieved, so a short read is caught instead of guessed at: add a +top-level "coverage" object mapping each FILE_LIST path you extracted to the number of lines you +read, e.g. {"coverage": {"docs/plan.md": 452}}. If you could not reach a file's last line, still +report the count you did read. A short count is recoverable - Step B3 warns, the entry is cached +as partial, and the next --update retries the file - whereas a missing entry is indistinguishable +from a complete read. + Rules: - EXTRACTED: relationship explicit in source (import, call, citation, "see §3.2") - INFERRED: reasonable inference (shared data structure, implied dependency) @@ -58,10 +74,10 @@ confidence_score is REQUIRED on every edge - never omit it, never use 0.5 as a d the edge AMBIGUOUS rather than picking 0.4 or below. - AMBIGUOUS edges: 0.1-0.3 -Node ID format: lowercase, only `[a-z0-9_]`, no dots or slashes. Format: `{stem}_{entity}` where stem is the **full repo-relative path with the extension dropped**, every path segment kept and joined with `_` (each segment lowercased with non-alphanumeric chars replaced by `_`), and entity is the symbol name similarly normalized. Use every directory level, not just the immediate parent — this keeps same-named files in different directories distinct. Examples: `src/auth/session.py` + `ValidateToken` → `src_auth_session_validatetoken`; `lib/utils/helpers.py` + `parse_url` → `lib_utils_helpers_parse_url`; `tests/test_foo.py` + `_helper` → `tests_test_foo_helper`; `docs/v1/api/README.md` + `getUser` → `docs_v1_api_readme_getuser`. Top-level files (no parent dir, e.g. `setup.py`) use just the filename stem: `setup_my_func`. This must match the ID the AST extractor generates — using just the filename (e.g., `session_validatetoken`) or only the immediate parent (e.g., `auth_session_validatetoken`) will create orphan ghost-duplicate nodes. If you are re-extracting a project built under the old immediate-parent format, the user should run `graphify extract --force` to rebuild cleanly. CRITICAL: never append chunk numbers, sequence numbers, or any suffix to an ID (no `_c1`, `_c2`, `_chunk2`, etc.). IDs must be deterministic from the label alone — the same entity must always produce the same ID regardless of which chunk processes it. +Node ID format: lowercase, word characters only (`[^\W]` after casefolding — `[a-z0-9_]` for ASCII input, but non-ASCII letters and digits are kept as-is), no dots or slashes. Format: `{stem}_{entity}` where stem is the **full repo-relative path with the extension dropped**, every path segment kept and joined with `_` (each segment lowercased with non-alphanumeric chars replaced by `_`), and entity is the symbol name similarly normalized. Use every directory level, not just the immediate parent — this keeps same-named files in different directories distinct. Examples: `src/auth/session.py` + `ValidateToken` → `src_auth_session_validatetoken`; `lib/utils/helpers.py` + `parse_url` → `lib_utils_helpers_parse_url`; `tests/test_foo.py` + `_helper` → `tests_test_foo_helper`; `docs/v1/api/README.md` + `getUser` → `docs_v1_api_readme_getuser`. Top-level files (no parent dir, e.g. `setup.py`) use just the filename stem: `setup_my_func`. This must match the ID the AST extractor generates — using just the filename (e.g., `session_validatetoken`) or only the immediate parent (e.g., `auth_session_validatetoken`) will create orphan ghost-duplicate nodes. If you are re-extracting a project built under the old immediate-parent format, the user should run `graphify extract --force` to rebuild cleanly. CRITICAL: never append chunk numbers, sequence numbers, or any suffix to an ID (no `_c1`, `_c2`, `_chunk2`, etc.). IDs must be deterministic from the label alone — the same entity must always produce the same ID regardless of which chunk processes it. Generate the extraction JSON matching this schema exactly: -{"nodes":[{"id":"auth_session_validatetoken","label":"Human Readable Name","file_type":"code|document|paper|image|rationale|concept","source_file":"","source_location":null,"source_url":null,"captured_at":null,"author":null,"contributor":null}],"edges":[{"source":"node_id","target":"node_id","relation":"calls|implements|references|cites|conceptually_related_to|shares_data_with|semantically_similar_to|rationale_for","confidence":"EXTRACTED|INFERRED|AMBIGUOUS","confidence_score":1.0,"source_file":"","source_location":null,"weight":1.0}],"hyperedges":[{"id":"snake_case_id","label":"Human Readable Label","nodes":["node_id1","node_id2","node_id3"],"relation":"participate_in|implement|form","confidence":"EXTRACTED|INFERRED","confidence_score":0.75,"source_file":""}],"input_tokens":0,"output_tokens":0} +{"nodes":[{"id":"auth_session_validatetoken","label":"Human Readable Name","file_type":"code|document|paper|image|rationale|concept","source_file":"","source_location":null,"source_url":null,"captured_at":null,"author":null,"contributor":null}],"edges":[{"source":"node_id","target":"node_id","relation":"calls|implements|references|cites|conceptually_related_to|shares_data_with|semantically_similar_to|rationale_for","confidence":"EXTRACTED|INFERRED|AMBIGUOUS","confidence_score":1.0,"source_file":"","source_location":null,"weight":1.0}],"hyperedges":[{"id":"snake_case_id","label":"Human Readable Label","nodes":["node_id1","node_id2","node_id3"],"relation":"participate_in|implement|form","confidence":"EXTRACTED|INFERRED","confidence_score":0.75,"source_file":""}],"input_tokens":0,"output_tokens":0,"coverage":{"":0}} source_file RULE (every node, edge, and hyperedge): set source_file to the path of the originating file EXACTLY as it appears in FILE_LIST — verbatim and absolute. Do NOT shorten to a basename, do NOT re-relativize, do NOT strip any directory prefix, and do NOT change separators (the engine canonicalizes separators and relativizes against the build root downstream). Copy the FILE_LIST entry character-for-character. This keeps the full build and incremental --update on the same base, so build_merge's replace-on-re-extract matches the existing node instead of accumulating a duplicate. diff --git a/home/dot_claude/skills/graphify/references/hooks.md b/home/dot_claude/skills/graphify/references/hooks.md index 438b8b1..fec29d3 100644 --- a/home/dot_claude/skills/graphify/references/hooks.md +++ b/home/dot_claude/skills/graphify/references/hooks.md @@ -31,3 +31,18 @@ This writes a `## graphify` section to the local `CLAUDE.md` that instructs Clau ```bash graphify claude uninstall # remove the section ``` + +## Source-read freshness + +The source-read guard treats a file newer than `graph.json` as potentially stale, +but a checkout can refresh timestamps without changing content. For newer files, +the guard checks the exact project-relative path (or an exact legacy absolute +path) in the configured output directory's extraction manifest. Every populated +AST/semantic hash must match the current content; a matching tier cannot hide a +stale tier. Unchanged content retains the normal graph guidance and strict-mode +first-read deny. + +Missing, unreadable, malformed or oversized manifests, unknown paths, and absent +or invalid hashes retain the conservative stale soft nudge. A `needs_update` +marker always softens the guard, even when content matches. Older-mtime files +are not hashed; this is a checkout-timestamp check, not a full freshness audit. diff --git a/home/dot_claude/skills/graphify/references/query.md b/home/dot_claude/skills/graphify/references/query.md index 56565eb..42521d2 100644 --- a/home/dot_claude/skills/graphify/references/query.md +++ b/home/dot_claude/skills/graphify/references/query.md @@ -80,7 +80,6 @@ If the CLI is unavailable, load `graphify-out/graph.json` and run the traversal $(cat graphify-out/.graphify_python) -c " import sys, json from networkx.readwrite import json_graph -import networkx as nx from pathlib import Path data = json.loads(Path('graphify-out/graph.json').read_text(encoding='utf-8')) @@ -105,7 +104,6 @@ if not start_nodes: sys.exit(0) subgraph_nodes = set() -subgraph_edges = [] if mode == 'dfs': # DFS: follow one path as deep as possible before backtracking. @@ -121,7 +119,6 @@ if mode == 'dfs': for neighbor in G.neighbors(node): if neighbor not in visited: stack.append((neighbor, depth + 1)) - subgraph_edges.append((node, neighbor)) else: # BFS: explore all neighbors layer by layer up to depth 3. frontier = set(start_nodes) @@ -132,10 +129,20 @@ else: for neighbor in G.neighbors(n): if neighbor not in subgraph_nodes: next_frontier.add(neighbor) - subgraph_edges.append((n, neighbor)) subgraph_nodes.update(next_frontier) frontier = next_frontier +# Traversal chooses the nodes; collect relationships separately so seed edges, +# cycles, and cross-links are not lost just because both endpoints were visited. +# Taking the induced subgraph also keeps edges to nodes beyond the depth limit +# out of the result. data=True retains each edge's own attributes, including +# distinct parallel relationships in a MultiGraph. +subgraph_edges = [ + (u, v, edge_data) + for u, v, edge_data in G.subgraph(subgraph_nodes).edges(data=True) + if u != v +] + # Token-budget aware output: rank by relevance, cut at budget (~4 chars/token) token_budget = BUDGET # default 2000 char_budget = token_budget * 4 @@ -151,10 +158,9 @@ lines = [f'Traversal: {mode.upper()} | Start: {[G.nodes[n].get(\"label\",n) for for nid in ranked_nodes: d = G.nodes[nid] lines.append(f' NODE {d.get(\"label\", nid)} [src={d.get(\"source_file\",\"\")} loc={d.get(\"source_location\",\"\")}]') -for u, v in subgraph_edges: +for u, v, edge_data in subgraph_edges: if u in subgraph_nodes and v in subgraph_nodes: - _raw = G[u][v]; d = next(iter(_raw.values()), {}) if isinstance(G, nx.MultiGraph) else _raw - lines.append(f' EDGE {G.nodes[u].get(\"label\",u)} --{d.get(\"relation\",\"\")} [{d.get(\"confidence\",\"\")}]--> {G.nodes[v].get(\"label\",v)}') + lines.append(f' EDGE {G.nodes[u].get(\"label\",u)} --{edge_data.get(\"relation\",\"\")} [{edge_data.get(\"confidence\",\"\")}]--> {G.nodes[v].get(\"label\",v)}') output = '\n'.join(lines) if len(output) > char_budget: @@ -165,6 +171,8 @@ print(output) Replace `QUESTION` with the **expanded** query string, `MODE` with `bfs` or `dfs`, and `BUDGET` with the token budget (default `2000`, or whatever `--budget N` specifies). Then answer based on the subgraph output above, using only what the graph contains. +**Bypass check (hub/bridge questions only, #4426).** If the question is about why a node bridges communities or has unusually many edges (a hub/god node), the neighbour listing above only shows code that already has an edge to it — it cannot show code that does the hub's job without ever calling it. Before finalizing the answer: pick one or two literal, distinctive things the hub does (a hard-coded constant it wraps, a specific string it returns, the exact computation in its body), then grep the corpus for that literal text in files that have **no edge** to the hub node in the subgraph above. Report any hits separately, labeled "Bypasses", distinct from the normal neighbour list — each is a file that reimplements the hub instead of using it. Also check whether the hub's own community label names a different node: a shared utility is often clustered into its heaviest consumer's community, so the label can read as if that consumer were the bridge. If so, say so plainly in the answer rather than letting the label stand unquestioned. + After writing the answer, save it back into the graph so it improves future queries. Include the expanded tokens inside the `--answer` text (e.g. `"Expanded from original query via vocab: [tokens]. Then traversed..."`) so the next `--update` extracts the expansion history as a graph node: ```bash diff --git a/home/dot_claude/skills/graphify/references/update.md b/home/dot_claude/skills/graphify/references/update.md index 3632fd4..c17281b 100644 --- a/home/dot_claude/skills/graphify/references/update.md +++ b/home/dot_claude/skills/graphify/references/update.md @@ -12,9 +12,24 @@ import sys, json from graphify.detect import detect_incremental, save_manifest from pathlib import Path -result = detect_incremental(Path('INPUT_PATH')) +from graphify.paths import out_path +from graphify.watch import _read_build_excludes, _read_build_gitignore +# Step B3.5 lists the files this run reads only partway, and the manifest write (and Step 9, +# if it runs) keeps them unstamped. Only B3.5 rewrites the list, so drop one an earlier run +# left: it would keep a file this run serves from the cache unstamped on every run (#4807). +Path('graphify-out/.graphify_partial.txt').unlink(missing_ok=True) +result = detect_incremental(Path('INPUT_PATH'), extra_excludes=_read_build_excludes(out_path()), gitignore=_read_build_gitignore(out_path())) new_total = result.get('new_total', 0) -print(json.dumps(result, indent=2, ensure_ascii=False)) +nf = result.get('new_files', {}) +print(json.dumps({ + 'new_total': new_total, + 'deleted': len(result.get('deleted_files', [])), + 'new_by_type': {t: len(v) for t, v in nf.items()}, + 'total_files': result.get('total_files'), + 'total_words': result.get('total_words'), + 'skipped_sensitive': result.get('skipped_sensitive', []), +}, indent=2, ensure_ascii=False)) +print('Full result: graphify-out/.graphify_incremental.json') Path('graphify-out/.graphify_incremental.json').write_text(json.dumps(result, ensure_ascii=False), encoding=\"utf-8\") deleted = list(result.get('deleted_files', [])) if new_total == 0 and not deleted: @@ -61,7 +76,7 @@ print('code_only:', code_only) " ``` -If `code_only` is True: print `[graphify update] Code-only changes detected - skipping semantic extraction (no LLM needed)`, run only Step 3A (AST) on the changed files, skip Step 3B entirely (no subagents), then go straight to merge and Steps 4–8. +If `code_only` is True: print `[graphify update] Code-only changes detected - skipping semantic extraction (no LLM needed)`, run Step 3A (AST) on the changed files, then follow only Part B's **Fast path** to overwrite `.graphify_semantic.json` with an empty result and run Part C to create `.graphify_extract.json` from the fresh AST result. Skip semantic cache checks/writes and subagents (Steps B0–B3); do not reuse semantic sidecars from a prior run. Continue to the incremental merge and Steps 4–8 only after Part C has completed. If `code_only` is False (any changed file is a doc/paper/image/video): **first, if any changed file is in `new_files['video']`, run `references/transcribe.md` (Step 2.5) on those files, then rewrite `.graphify_detect.json` to move the resulting transcript paths into `files['document']` and drop `files['video']`** — otherwise raw `.mp4/.mp3` paths are fed to semantic subagents as unreadable media (#1392). Then run the full Steps 3A–3C pipeline as normal. @@ -96,7 +111,7 @@ deleted = list(incremental.get('deleted_files', [])) # prune_sources is ONLY for genuinely DELETED files. Changed/re-extracted files are # handled by build_merge's replace-on-re-extract (#1344): every source_file in # new_chunks is dropped from the base before merge, so old/stale nodes don't survive. -# Do NOT add `changed` here: with root= passed, prune_set relativizes to the same base +# Do NOT add changed here: with root= passed, prune_set relativizes to the same base # as the freshly merged nodes and would DELETE the re-extracted content (#1178 is moot # now that replace — not the dedup pass — reconciles changed files). prune = list(deleted) or None @@ -150,7 +165,13 @@ print(f'[graphify update] Merged extraction written ({len(merged_out[\"nodes\"]) # is lost forever (#2015). Mirrors the library extract path # (cli._stamped_manifest_files + clear_semantic + scan_corpus). from graphify.cli import _stamped_manifest_files -_manifest_files = _stamped_manifest_files(incremental['files'], new_extraction, Path('INPUT_PATH')) +# A file a subagent only partly read (Step B3.5 lists it) DID produce output, so the +# filter alone would stamp it and the next --update would never re-queue it. Pass the +# list as Step 9 does after a full build, so it stays unstamped and is retried (#2225, #4807). +# Leave the list on disk: Step 9 reads it too if it runs after the update. +_pf = Path('graphify-out/.graphify_partial.txt') +_partial = {l.strip() for l in _pf.read_text(encoding='utf-8').splitlines() if l.strip()} if _pf.exists() else set() +_manifest_files = _stamped_manifest_files(incremental['files'], new_extraction, Path('INPUT_PATH'), partial_source_files=_partial) # Changed semantic files dispatched this run but NOT stamped had their chunk fail # or be omitted; clear any stale semantic_hash so they are re-queued (#1948). _sem_types = ('document', 'paper', 'image') @@ -174,7 +195,7 @@ $(cat graphify-out/.graphify_python) -c " import json from graphify.analyze import graph_diff from graphify.build import build_from_json -from networkx.readwrite import json_graph +from graphify.paths import load_node_link_graph import networkx as nx from pathlib import Path @@ -184,7 +205,7 @@ new_extract = json.loads(Path('graphify-out/.graphify_extract.json').read_text(e G_new = build_from_json(new_extract, directed=IS_DIRECTED) if old_data: - G_old = json_graph.node_link_graph(old_data, edges='links') + G_old = load_node_link_graph(old_data) diff = graph_diff(G_old, G_new) print(diff['summary']) if diff['new_nodes']: diff --git a/home/dot_config/mise/config.toml.tmpl b/home/dot_config/mise/config.toml.tmpl index 8511762..8bdebb2 100644 --- a/home/dot_config/mise/config.toml.tmpl +++ b/home/dot_config/mise/config.toml.tmpl @@ -11,7 +11,7 @@ basecamp = { version = "latest", lazy = true, lazy_bins = ["basecamp"] } muse = { version = "latest", lazy = true, lazy_bins = ["muse"] } bat = "0.26.1" -chezmoi = "2.72.1" +chezmoi = "2.74.0" # The one tool here deliberately not pinned, decided 10 September 2026. # # Everything else in this file is pinned because a version that moves under you @@ -29,22 +29,22 @@ chezmoi = "2.72.1" # at the same moment, and a session's behaviour is no longer reproducible from # this file alone. `claude --version` is where that question gets answered now. claude = "latest" -fzf = "0.74.3" +fzf = "0.74.5" lsd = "1.2.0" -fd = "10.5.0" -lazygit = "0.64.1" -node = "26.8.1" +fd = "10.5.1" +lazygit = "0.66.2" +node = "26.13.0" # mason installs pip-backed packages (ruff) into a venv; without a # python3 on PATH those installs fail python = "3.14.7" ripgrep = "15.2.0" -neovim = "0.12.5" -direnv = "2.37.1" +neovim = "0.12.6" +direnv = "2.38.2" # Shell history in SQLite; sync off, see ~/.config/atuin/config.toml. -atuin = "18.21.0" -yq = "4.53.6" +atuin = "18.24.5" +yq = "4.54.1" jq = "1.8.2" -delta = "0.19.2" +delta = "0.20.1" zoxide = "0.10.0" # Runtime for coding agents. The mise registry entry resolves through # `ogulcancelik/herdr`, which is a rename that redirects to `herdrdev/herdr` — @@ -52,12 +52,12 @@ zoxide = "0.10.0" # API rather than assumed. Worth writing down because a registry name pointing # at a different owner than the project is exactly the shape a squat would # take, and the next person to look will have the same doubt. -herdr = "0.8.2" -gh = "2.100.0" +herdr = "0.9.5" +gh = "2.103.3" tmux = "3.7c" # Picker over tmux sessions plus zoxide's frecency list. Not in the mise # registry, so the github backend fetches the release binary. -"github:joshmedeski/sesh" = "2.29.0" +"github:joshmedeski/sesh" = "2.34.0" # Channel-based fuzzy finder. Takes Ctrl-T, Alt-C and the sesh picker off fzf, # and puts every channel — git branches, k8s pods, systemd units — one # keystroke away. fzf stays pinned regardless: fzf-tab, the zsh completion @@ -73,12 +73,12 @@ yazi = "26.9.1" # ping. In mise rather than the host package list for the same reason as yazi: # a devpod container has no pacman, so anything not pinned here simply isn't # there. -dust = "1.2.5" +dust = "1.2.7" duf = "0.9.1" -btop = "1.4.7" +btop = "1.4.8" sd = "1.1.0" jless = "0.9.0" -hyperfine = "1.20.0" +hyperfine = "2.0.0" gping = "1.21.0" # github, not cargo: the cargo backend compiles from source and so needs a Rust # toolchain, while this pulls the cargo-dist binary straight from the release @@ -93,7 +93,7 @@ gping = "1.21.0" # rtk-ai/rtk, so a plain pin works everywhere and Renovate bumps it. Watch the # name collision noted in dot_claude/CLAUDE.md: reachingforthejack/rtk is a # different tool ("Rust Type Kit"). `rtk gain` working is the cheap check. -rtk = "0.48.0" +rtk = "1.1.0" {{ if contains " work " (includeTemplate "profiles" .) -}} # Jira from the terminal, on a work machine only — the first gated tool here, # and the shape every later one follows. See docs/design-notes.md, "Profiles". @@ -109,8 +109,8 @@ rtk = "0.48.0" age = "1.3.2" # nvim-treesitter (main branch) shells out to the tree-sitter CLI to # compile parsers; without it :TSUpdate fails and parsers go stale -tree-sitter = "0.27.0" -uv = "0.12.9" +tree-sitter = "0.27.1" +uv = "0.13.7" # uvx_args: pomo imports typing_extensions but doesn't declare it; on # python >=3.14 nothing pulls it in transitively anymore. # @@ -130,7 +130,7 @@ uv = "0.12.9" # Builds a knowledge graph of a codebase. The `/graphify` skill it ships is # vendored into dot_claude/skills rather than left to `graphify install`, so a # fresh machine gets it from an apply. -"pipx:graphifyy" = "0.9.53" +"pipx:graphifyy" = "0.9.102" # Gemini's image models behind an MCP server, so Impeccable finds a # harness-native image tool and never reaches for its OpenAI fallback. Reads # GEMINI_API_KEY from the environment; ~/.local/bin/gemini-image-mcp is what puts @@ -144,14 +144,9 @@ uv = "0.12.9" # the same way before bumping, because the name is the only thing a lookalike # would need. # -# fastmcp is pinned with it because 0.4.5 asks for `fastmcp>=2.11.0` with no -# ceiling, and fastmcp 4.0.0 landed on 31 August 2026 — after this package's -# last commit — moving `fastmcp.tools.tool`. Resolved fresh, the server dies on -# import with ModuleNotFoundError before it serves anything. 3.4.7 is the last -# 3.x and is pinned exactly rather than as `<4`, both because this repo pins to -# immutable versions and because a `<` in an args string is a shell -# metacharacter waiting to be interpreted by something. -"pipx:nanobanana-mcp-server" = { version = "0.4.5", uvx_args = "--with fastmcp==3.4.7" } +# 0.4.6 now declares its compatible FastMCP range itself, so no transitive +# override is needed here. +"pipx:nanobanana-mcp-server" = "0.4.6" # The five below were added on this machine with `mise use`, which writes # ~/.config/mise/config.toml directly and so never reached this template. An @@ -165,7 +160,7 @@ uv = "0.12.9" # version to bump. Pinned to what was current when they were adopted. # # OpenAI's agent CLI, alongside Claude Code above rather than instead of it. -codex = "0.152.0" +codex = "0.163.0" # Both are also pinned in this repo's own mise.toml, which is repo tooling and # never applied into $HOME. These copies are what put them on a machine's PATH # generally -- the versions are allowed to drift apart, since one answers "what @@ -174,8 +169,8 @@ actionlint = "1.7.12" shellcheck = "0.11.0" # The homelab is a Kubernetes cluster whose manifests are reconciled by Flux, so # these two are how it is reached and inspected at all. -kubectl = "1.37.0" -flux2 = "2.9.5" +kubectl = "1.37.2" +flux2 = "2.10.0" [settings] # run pipx-backend tools through uvx so no system python/pipx is needed diff --git a/mise.toml b/mise.toml index 20dc8ee..23d0139 100644 --- a/mise.toml +++ b/mise.toml @@ -12,7 +12,7 @@ bats = "1.14.0" # The suite renders a script template, so the tests need chezmoi itself. Kept at # the same version as the machines install; the lint task below asserts all # three copies of this number agree. -chezmoi = "2.72.1" +chezmoi = "2.74.0" # renovate stays an `npx --yes` call rather than a mise tool: it is run by this # one lint line only. @@ -32,7 +32,7 @@ run = [ # the fixed-point property — is covered by tests/modify-settings.bats. Two # unreadable one-liners used to live here instead. # renovate: datasource=npm depName=renovate - "npx --yes --package renovate@44.65.5 renovate-config-validator .github/renovate.json", + "npx --yes --package renovate@44.221.6 renovate-config-validator .github/renovate.json", # The facts this repo states in more than one place — the three chezmoi # versions, the vault name, the two container markers, the bootstrap PAT's # expiry, the vendored graphify skill's version, the cached PAT's path. Each