17 commits

Author	SHA1	Message	Date
Shifra Williams	a6a8aa788c	feat(serve): validate and port-scope the origin/proxy configuration surface (#2820)	2026-08-05 06:52:39 +01:00
Claude	eea9ac92dc	ci: move Node pins to the 22.18 floor ... With the supported minimum raised to Node 22.18, retarget every lane and pinned runtime that sat at a lower version so nothing builds or runs the package on an unsupported (EBADENGINE-warning) Node: - ci-tests.yml: node-floor-compat 22.14 -> 22.18.0 (name, comment, pin, version assertion) so the floor gate guards the new minimum; its #2372 registerHooks failure mode cannot recur above 22.15. Containment-canary pin 22.16.0 -> 22.18.0. - gitnexus-review-agent.yml + the pinned review/canary runtime: the reproducible runtime is version-locked in lockstep across .github/{gitnexus-review-runtime,claude-canary-runtime}/package.json and their lockfiles (engines), the workflow's node-version, its two 'node --version = v22.18.0' assertions, the lockfile-engines guard, and NODE_VERSION. Moved all of them 22.16.0 -> 22.18.0. - gitnexus-skill-evolution.yml: pinned runtime 22.16.0 -> 22.18.0. - CONTRIBUTING.md prerequisite floor updated. - review-agent-workflow.test.ts, which enforces the runtime lock, updated to expect 22.18.0. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-21 10:09:34 +00:00
EVA	24d8d1ea38	docs: build shared package before CLI setup (#2448) ... Co-authored-by: Eva <eva@100yen.org> Co-authored-by: Gergő Magyar <gergomagyar@icloud.com>	2026-07-16 07:00:21 +01:00
Gergő Magyar	187c162fd8	feat: full Codex support — hooks, plugin marketplace, and setup (#2328, supersedes #1131) (#2369) ... * feat(setup): install Codex PreToolUse/PostToolUse hooks (#2328) Codex CLI supports lifecycle hooks with Claude Code's exact {hooks: {Event: [...]}} JSON schema, stdin payload, and hookSpecificOutput response contract, registered in a dedicated ~/.codex/hooks.json (https://developers.openai.com/codex/hooks). Parameterize installClaudeCodeHooks into installClaudeSchemaHooks (claude | codex): both runtimes share the installer, the bundled gitnexus-hook.cjs adapter, and its helpers. A codex HookTarget in editor-targets.ts makes uninstall and the setup-uninstall round-trip tripwire cover the new surface with no uninstall.ts changes. SessionStart is deliberately not registered: Codex reads AGENTS.md natively, which already carries the GitNexus context block. Closes #2328. Closes #244 (Codex setup support is now complete: MCP + skills + hooks). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * feat(plugin): make the GitNexus plugin installable from Codex (#1131) Codex's plugin system (https://developers.openai.com/codex/plugins/build) reads a .codex-plugin/plugin.json manifest and a repo-root .agents/plugins/marketplace.json registry. The existing gitnexus-claude-plugin/ is already Codex-compatible as-is — Codex sets CLAUDE_PLUGIN_ROOT for hook-command compatibility, loads the same SKILL.md skills, hooks/hooks.json, and .mcp.json — so a second manifest in the same folder replaces PR #1131's duplicated plugin tree with zero copied skills or hooks. The .gitignore .agents/ scratch rule narrows to re-include only the registry file. Install: codex plugin marketplace add abhigyanpatwari/GitNexus Supersedes #1131. Co-authored-by: jublin <1799126+jublin@users.noreply.github.com> Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * docs: document Codex full support (MCP + skills + hooks + plugin) Promote Codex to Full in both editor tables, document the ~/.codex/hooks.json hook install, and add the Codex plugin marketplace install path. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * test(release): extend the version-lockstep guard to the Codex manifests The always-on drift guard asserted only the Claude plugin manifests against gitnexus/package.json, so a release could ship stale versions in .codex-plugin/plugin.json and .agents/plugins/marketplace.json without CI noticing. Mirror the Claude lockstep test for the two Codex files and extend the CONTRIBUTING §Releases lockstep list to match. Verified guard semantics: a deliberate local version mutation of the Codex marketplace entry turns the new test red. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * fix(plugin): quote the hook command path for space-containing plugin roots Both plugin hook commands ran `node ${CLAUDE_PLUGIN_ROOT}/hooks/...` unquoted, which breaks whenever the substituted plugin root contains a space — the common case on Windows user profiles. Both Claude Code and Codex substitute the placeholder before shell execution, and Claude Code's plugin docs mandate the double-quoted form in shell-form hooks. No commandWindows entry: Codex source (codex-rs hooks engine) falls back to `command` on Windows with identical placeholder substitution, so an identical-content override would be pure duplication. Verified: space-in-root smoke test (old form exits 1 MODULE_NOT_FOUND, quoted form exits 0), `claude plugin validate` passes, and a local `codex plugin marketplace add` parses the marketplace + plugin cleanly. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * test(setup): pin fail-closed behavior for unreadable/corrupt Codex hooks.json The non-ENOENT suite covered Claude settings.json (EACCES) and Codex config.toml (EACCES) but not the new ~/.codex/hooks.json surface, and the mergeHooksJsonc "is corrupt" branch had zero coverage for either editor. A future refactor dropping the isEnoent rethrow or the parse gate could silently rewrite a user's hooks.json gitnexus-only with no CI tripwire. Two regression tests: EACCES leaves hooks.json byte-identical and reports "Codex hooks: EACCES"; corrupt content is preserved and reported via "Codex hooks: hooks.json is corrupt". Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * docs(readme): add the Codex plugin-marketplace install path to the npm README The root README documents the one-step plugin route but the package README (what npmjs.com renders) only showed the setup-CLI path. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * refactor(setup): rename claudeHook to hookCfg in installClaudeSchemaHooks The local held a codex HookTarget on the codex branch since the installer was parameterized, so the claude-specific name misled. Pure local rename, no behavior change. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * docs(readme): document Codex SessionStart exclusion, /hooks trust gate, and install-route choice Three behaviors were only recorded in code comments and the PR body: SessionStart is deliberately not registered (Codex reads AGENTS.md natively), setup-installed hooks need one-time /hooks approval in Codex, and the setup CLI and plugin are alternative install routes whose hooks load alongside each other if both are used. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> * refactor(test): share one logLines helper across setup.test.ts describes The corrupt-hooks.json test inlined the console.log-flattening expression that the non-ENOENT describe already defined locally. Hoist a single file-scope logLines so the two stay in sync. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com>	2026-07-04 13:32:17 +01:00
Gergő Magyar	96dc368d96	fix(ci): align tree-sitter readiness + grammar-update workflows on a shared manifest (#858) (#2187) ... * chore(ci): add shared vendored-grammars manifest; monitor reads it .github/vendored-grammars.json is the single source of truth for the vendored tree-sitter grammars (c/swift/kotlin/dart/proto): name, upstream coords, and policy holds. update-vendored-grammars.mjs now builds its GRAMMARS map from the manifest (behavior-preserving — same exported shape). Adds manifest-agreement tests so the loader can't silently skew from the file. * fix(ci): classify vendored grammars from manifest, drop bare "?" (#858) The readiness report decided "is this vendored?" via is_vendored_pin (a file: package.json spec) — but the 5 vendored grammars aren't in package.json, so they were misrouted through the npm path and rendered bare "?" for ABI (read from an empty node_modules), plus a spurious "? (fetch failed)" for github-only proto. Now vendored grammars are classified by membership in the shared manifest and their ABI is read from gitnexus/vendor/<name>/src/parser.c (always in a checkout). github-only vendored grammars skip the npm peer-dep fetch; the tree-sitter-c hold is surfaced from the manifest (held, not plain "Ready"); and every remaining unintrospectable value renders a labeled token, never a bare "?". --assert-current now covers the vendored grammars too instead of skipping them. Adds a stdlib unittest suite incl. a manifest⇄vendor-dir consistency guard. * docs(ci): document the shared vendored-grammars manifest Both tree-sitter workflow headers now point at .github/vendored-grammars.json as the shared source of truth; the readiness workflow gains a PR-path trigger on the manifest + test, and runs the readiness unit tests on validation events. CONTRIBUTING.md documents the manifest contract under CI automation contracts. * fix(review): apply autofix feedback - Guard manifest reads in both scripts with a clear error (was an opaque module-import traceback that crashed the script and test collection). - Never render a bare "?": relabel the npm-path ABI/version/peer sentinels and the vendored upstream-ABI miss to labeled tokens; the report is now ?-free regardless of node_modules/network, and the test is hermetic. - Add a VENDORED_NAMES ⊆ GRAMMARS guard + manifest-missing error test. - Drop now-dead is_vendored_pin/is_vendored/_(vendored)_. - Compose held + out-of-range vendored blocker reasons instead of overwriting. - Reword the shared-manifest docs to not over-claim shared upstream coords. * fix(ci): apply root prettier formatting to mjs + ts test The quality/format gate runs root `prettier --check .` (printWidth 100, the gitnexus-local config differs and falsely passed locally). * test(ci): make both tree-sitter scripts testable offline The scripts hit live npm/GitHub, which makes the report run flaky and the monitor's detect/apply logic untestable. Add hermetic seams: - readiness: --offline flag (+ GITNEXUS_TS_READINESS_OFFLINE env) no-ops the npm registry + upstream fetches; the report renders deterministically (vendored ABIs from the repo, npm columns marked 'offline', no bare '?'). 3 tests assert an offline run touches ZERO network (urlopen patched to raise). - monitor: detect() and apply() accept injected deps (vendoredVersion/ resolveUpstream/fetchSource/readAbi) so the newer/ABI/hold gating runs offline with fixtures; apply gains --dry-run (validates but writes nothing). 6 tests cover newer/same-version/held-c/ABI-15/applicable + a no-mutation dry-run. * fix(review): keep --assert-current hermetic + harden the no-bare-? invariant Tri-review findings (PR #2187): - P2 REGRESSION: --assert-current (documented 'hermetic and offline', run in CI without --offline) routed the 5 vendored grammars through vendored_drift_summary, which fetches upstream parser.c + commit sha — 10 discarded network calls per run. Fix: read the vendored ABI locally via a new vendored_abi_from_repo() helper (also used by vendored_drift_summary). Now verifiably network-free. - Unify the upstream-ABI miss sentinel: prose said 'n/a (generated at build)' while the matrix said 'n/a' — and 'generated at build' is a wrong cause (swift HAS a committed parser.c). Both now render neutral 'n/a'. - Fix the stale assert_current docstring claiming swift is prebuilt-only/no parser.c. - Guard the last latent bare-? path (vendor package.json missing 'version'). Tests: AssertCurrent (network-free guard + out-of-range via the new injection point), malformed-JSON manifest, detect() error-path, explicit npm/github undefined assertions. 17 Python + 15 vitest, all hermetic. * fix(review): use a single unittest import style (CodeQL 753) CodeQL py/import-and-import-from flagged `import unittest` + `from unittest import mock`. Collapse to `from unittest import TestCase, main, mock`. * fix(review): explicit raise in _matrix_row (CodeQL 754) CodeQL py/mixed-returns flagged the implicit fall-through after self.fail() (which it doesn't model as NoReturn). End with an explicit raise AssertionError. * test(review): replace non-null assertions with a must() guard @typescript-eslint/no-non-null-assertion flagged 4 `!` operators. Add a narrowing must<T>(value, message) helper (throws on undefined) and a named baseResolveUpstream, removing every non-null assertion. * fix(review): unguessable heredoc delimiter for the report output The report embeds the manifest `hold` field (fork-PR-editable); a fixed DRIFT_EOF delimiter in a hold value could close the $GITHUB_OUTPUT heredoc early and inject output keys. Use DRIFT_EOF_$(openssl rand -hex 16) — a value the report cannot contain. (Randomized delimiter over base64: keeps REPORT raw markdown, no consumer-side decode.) * fix(review): scope issues:write to scheduled runs (two-job split) GitHub Actions has no step-level permissions, so the only way to keep PR runs (incl. forks) from receiving `issues: write` is to split the job. A `report` job (contents:read, all events) renders the report + the PR `:⚠️:` and exposes report/exit_code as job outputs; a schedule-only `upsert-issue` job (needs: report, issues:write, no checkout) consumes them for the issue upsert + close. The 'Check upgrade readiness' check name is preserved. * fix(review): launder npm-version '?' in disposition prose The disposition bucket prose interpolated r['npm_version'] raw, so a successful 200 npm /latest response lacking a 'version' key would render a bare '?' (the matrix cell already laundered it). Add npm_version_label ('unknown' for '?') and use it in all five bucket renderers. Test a version-less npm response. * refactor(review): load_vendored_manifest returns only the consumed 'hold' The readiness script reads only the grammar names + 'hold'; the 'key' and 'upstream' fields were phantom data (upstream-drift coords live in the script's own GRAMMARS map). Narrow the return to {hold}. * fix(review): unify detect()/apply() 'newer' check for github grammars detect() compared the bare sha7 while apply() compared up.version (the full <base>-g<sha7> provenance string apply() also writes). After the bot re-vendored a github grammar once, detect() reported a perpetual false 'update available' while apply() correctly saw 'already current' — a noisy job summary + wasted --apply subprocess (the PR-exists guard absorbed it before any duplicate PR). Extract a shared isNewer(up, have) helper used by both. Tests cover equal- provenance (false), first-vendoring plain-version (true, not suppressed), and sha-advanced (true). Coupled with U12 (the detect⇄apply agreement assertion lives there once apply()'s not-newer path returns instead of process.exit). * test(review): cover main()'s out-of-range + prebuilt-only vendored ABI branches main()'s vendored-ABI classification reads through vendored_abi_from_repo (the local-read seam --assert-current uses), so patching it drives the 'Vendored (ABI out of range)' blocker branch and the prebuilt-only (vendored_abi None → 'prebuilt' cell, not '?') branch — neither reachable today since all 5 vendor dirs ship parser.c at ABI 14. * test(review): monitor-side manifest⇄vendor-dir consistency guard Mirror the Python consistency guard on the monitor side — the monitor consumes the same manifest and is the side that WRITES files from manifest `name`, so manifest/vendor-dir drift must fail CI here too. * fix(review): validate grammar names at manifest load (path-traversal guard) The manifest `name` is joined into gitnexus/vendor/<name> paths in both scripts (and apply() WRITES there), so reject any name not matching tree-sitter-[a-z0-9-]+ at the single load chokepoint — defense-in-depth even though the live trust boundary already prevents exploitation. loadManifestGrammars gains an injectable `raw` arg + export for testing; tests reject a '../etc' name in both scripts. * refactor(review): apply() throws ApplyExit; CLI maps to exit codes apply()'s 4 process.exit calls killed the vitest worker, blocking in-process tests of its error branches. Replace them with a thrown ApplyExit{code}; the not-newer (already-current) path returns `have` instead of exit(0). The isMain CLI block try/catches and maps ApplyExit.code → process.exit, so the monitor's subprocess contract (exit 0/2/3) is byte-identical (verified via subprocess smoke). Tests cover unknown-key=2, held=3, ABI-reject=3, and not-newer (returns current, no throw, no write). * refactor(review): extract vendored render helper; trim docstrings (<1000 lines) Extract the 'Vendored parsers' prose render into _render_vendored_section() so main() coordinates named phases rather than inlining a ~450-line monolith, and condense the most verbose docstrings/comments. The script drops from 1092 to 999 lines (under the 1000 bar the maintainability review flagged). Behavior-preserving: the deterministic --offline render is byte-identical before/after (verified in-place), --assert-current still passes, and the full unit suite is green. * fix(review): row-diff regex captures only the Status cell The change-detection regex captured the whole row tail as group 2, so any non-status cell drift (e.g. an upstream-ABI bump) emitted a false-positive 'change' line. Capture only the Status cell ([^|]+? before the final |$). The workflow parseRows regex and the Python _ROW_DIFF_RE stay byte-identical; the stability test now asserts group 2 is the status string (e.g. c → 'Vendored — held') and contains no pipe. * fix(ci): hoist intro string out of the list literal (CodeQL 755) The U13 extraction moved the 'Vendored parsers' intro paragraph (implicitly concatenated string literals) INTO a list literal, tripping CodeQL py/implicit-string-concatenation-in-list (reads as a possibly-missing comma between elements). Hoist it into a parenthesized `intro` variable. Render is byte-identical.	2026-06-13 16:15:49 +01:00
Copilot	689e6ef1f8	chore: Sync Claude plugin manifests with the 1.6.6 release (#2090) ... * Initial plan * fix: sync Claude plugin manifest versions * test: fold manifest sync check into existing node suite * chore(autofix): apply prettier + eslint fixes via /autofix command * test: run manifest sync guard in always-on suite --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2026-06-08 16:50:09 +01:00
Arvuno	16014657c8	docs: clarify local development setup in CONTRIBUTING (#2024) ... * docs: add CODEOWNERS (#2) * docs: add CI badge to README * docs: add CODEOWNERS file --------- Co-authored-by: Typo Fix Bot <fix@example.com> * docs: add CI badge to README (#1) Co-authored-by: Typo Fix Bot <fix@example.com> * docs: clarify local development setup in CONTRIBUTING * Update CODEOWNERS --------- Co-authored-by: Typo Fix Bot <fix@example.com> Co-authored-by: Arvuno <arvuno@nous.local> Co-authored-by: Gergő Magyar <gergomagyar@icloud.com>	2026-06-04 09:13:27 +01:00
Gergő Magyar	c4f82e4987	feat(devcontainer): add devcontainer for Claude/Codex/Cursor CLIs (#1875) ... * chore: extend .gitattributes for shell scripts and binary assets Append explicit `*.sh text eol=lf` and `*.bash text eol=lf` rules so shell scripts (notably anything COPYed into a Linux container) check out with LF endings on Windows hosts with `core.autocrlf=true`, regardless of the auto-detection on the existing `* text=auto eol=lf` line. Add binary markers for `*.node`, `*.wasm`, `*.onnx`, `*.so`, `*.dll`, `*.dylib` so native and ML model artifacts aren't ever subjected to text normalization. The existing `* text=auto eol=lf` and `.husky/* text eol=lf` rules are preserved. `git ls-files --eol` confirmed zero CRLF or mixed blobs in the index, so no `--renormalize` was needed. * feat(devcontainer): add cross-platform devcontainer for Claude Code, Codex, and Cursor CLIs Add a Dev Container that pre-installs Claude Code (2.1.153, via Anthropic's official Feature), OpenAI Codex CLI (pinned 0.134.0), and Cursor CLI alongside the GitNexus native build chain. Opens via VS Code's Dev Containers extension on Windows 11 (Docker Desktop + WSL2), macOS, or Linux without OS-specific branches in devcontainer.json. Topology and base - Base image `mcr.microsoft.com/devcontainers/typescript-node:1-22-bookworm` (multi-arch, monthly patched, ships the `node` non-root user, zsh, `gh`). - Node 22 LTS satisfies `gitnexus/`'s engines `>=22.0.0` and matches the `node:22-bookworm-slim` SHA-pinned base used by `Dockerfile.cli`. - Single container with all three CLIs co-installed (vs. docker-compose per-tool) — prevailing 2026 community pattern, lowest daily-driver friction. Persistence and auth - Per-devcontainer named volumes scoped by `${devcontainerId}` for `/home/node/.claude`, `/home/node/.codex`, `/home/node/.cursor`, `/commandhistory`, and `/home/node/.npm`. Authentication survives rebuilds without leaking between workspaces. - Four sub-workspace `node_modules` volumes (root, gitnexus, gitnexus-web, gitnexus-shared) keep tree-sitter native bindings and onnxruntime off the bind mount — the actual Win/Mac perf win. - Credential mount paths are pre-created in the Dockerfile with `chown node:node` BEFORE `USER node`, so empty named volumes inherit correct ownership on first mount and first-run logins don't EACCES. - `CURSOR_API_KEY` is injected via `containerEnv: ${localEnv:CURSOR_API_KEY}` (Cursor's documented headless path); falls back to interactive `cursor-agent login` when the host env var is unset. Build-arg promotion - Build args (`CLAUDE_CODE_VERSION`, `CODEX_VERSION`, `CURSOR_VERSION`, `TZ`) are promoted to ENV in the Dockerfile so lifecycle commands and shells can resolve them. Without this promotion, Docker ARG values are build-only and silently no-op at lifecycle time. Workspace setup - `postCreateCommand` chowns the four workspace `node_modules` volumes (Docker creates them root-owned), then installs in dependency order: root → gitnexus-shared (install + build) → gitnexus → gitnexus-web. The shared package must build before its consumers (`file:../gitnexus-shared`). Ports - 5173 (Vite dev) and 4173 (Vite preview) auto-forwarded. - 4747 (`gitnexus serve`) marked `requireLocalPort: true` because `gitnexus-web/src/services/backend-client.ts` hardcodes `http://localhost:4747` as the default backend URL; a remapped port would silently break the web UI. VS Code integration - Recommended extensions: `anthropic.claude-code`, `dbaeumer.vscode-eslint`, `esbenp.prettier-vscode`, `eamodio.gitlens`. - Settings: format-on-save with Prettier, ESLint auto-fix on save, zsh as default terminal profile, persistent zsh history via `HISTFILE` → `/commandhistory`. Documentation - `.devcontainer/README.md` covers WSL2 setup (clone inside WSL2 for IO and file-watcher reliability), first-time auth flows for each CLI, port- forwarding notes, LadybugDB container limitations, and the bumping procedure for each CLI version. - `CONTRIBUTING.md` gets a "Containerized development (optional)" subsection pointing at the devcontainer README. Deferred to a follow-up PR - Opt-in egress firewall (originally planned as a fourth implementation unit). The Dev Containers spec makes `runArgs` static — toggling `NET_ADMIN`/`NET_RAW` capabilities cleanly requires either a separate `devcontainer-firewall.json` profile or an `initializeCommand`-generated overlay. Keeping this PR focused on the working baseline. - Codespaces-specific tuning (works incidentally when the firewall is off, not actively tested). - Inside-container Playwright e2e (needs Chromium libs not in the base image). Verification deferred to user - This change introduces a new dev tooling artifact. Validate by running `docker build .devcontainer/`, opening the repo in VS Code via "Dev Containers: Reopen in Container", confirming `claude --version`, `codex --version`, `cursor-agent --version` resolve inside the container, and `cd gitnexus && npm run test:unit` runs clean against the named-volume `node_modules`. * fix(devcontainer): make interactive login the default auth path for all CLIs The previous `containerEnv` injected `CURSOR_API_KEY: "${localEnv:CURSOR_API_KEY}"`. When the host had no `CURSOR_API_KEY` set, this resolved to an empty string and Docker injected `CURSOR_API_KEY=""` into the container. Cursor CLI treats a set-but-empty `CURSOR_API_KEY` as "use this key" rather than "fall back to stored login", which silently broke `cursor-agent login` on the most common path — users who hadn't explicitly opted into API key auth. Drop `CURSOR_API_KEY` from `containerEnv`. Login is now the unconditional default for all three CLIs (Claude Code, Codex CLI, Cursor CLI); the named-volume + Dockerfile-chown pattern keeps credentials persistent across container rebuilds for every login path. Reorganize the README's auth section to put login first for all three CLIs uniformly (matching the new behavior) and move API key authentication into a separate "Alternative" section for CI/headless use. Document that API keys are intentionally not auto-propagated from the host and explain the export-in-shell or VS Code dotfiles-repo paths for users who want them. Update the troubleshooting row to reflect the new design. * fix(devcontainer): install gitnexus-web before gitnexus in postCreateCommand The previous order (root → gitnexus-shared → gitnexus → gitnexus-web) broke at the `gitnexus` install step because `gitnexus`'s `prepare` script runs `scripts/build.js`, which compiles `gitnexus-web` whenever its source tree exists. In the devcontainer the entire workspace is bind-mounted, so `gitnexus-web/` is present from the start — but its `node_modules/` wasn't yet, so `tsc -b` failed with: error TS2688: Cannot find type definition file for 'vite/client' error TS2688: Cannot find type definition file for 'node' Reorder so `gitnexus-web` installs before `gitnexus`. Verified end-to-end via `npx @devcontainers/cli up`: container builds clean, all three CLIs (Claude 2.1.153, Codex 0.134.0, Cursor) respond, and `npx tsc --noEmit` inside `/workspace/gitnexus` passes. Production Dockerfiles (`Dockerfile.cli` etc.) don't hit this because they only COPY `gitnexus/` + `gitnexus-shared/`, so `gitnexus-web/` doesn't exist at install time and `scripts/build.js` skips the web step. The devcontainer's full-tree bind mount changes that calculus. * fix(devcontainer): clear stale .husky/_ before npm install When `npm install` runs the root `prepare` script (husky), husky tries to copyfile `node_modules/husky/husky` → `.husky/_/h`. On Docker Desktop Windows bind mounts, if `.husky/_/` already exists from a prior container run, the new container's `node` user can't overwrite it via the bind mount's permission translation and the install fails with: Error: EPERM: operation not permitted, copyfile '/workspace/node_modules/husky/husky' -> '.husky/_/h' Drop `.husky/_` defensively in `postCreateCommand` before `npm install` so husky always starts from a clean slate. `.husky/_` is a husky runtime cache (gitignored), so removing it has no effect on the repo — husky regenerates it. No-op for WSL2-side checkouts (where this class of bind-mount permission collision doesn't occur). Add a troubleshooting row to `.devcontainer/README.md` covering the manual recovery (`rm -rf .husky/_` on the host) and the long-term fix (clone in WSL2 — Windows-side bind mounts will keep biting on this kind of issue across rebuilds with different UID alignment). * feat(devcontainer): bind-mount host CLI config dirs for plugin/skill/memory sync Switch the credential/config mounts from per-devcontainer named volumes to bind mounts of `${localEnv:HOME}/.claude`, `~/.codex`, and `~/.cursor`. Effect inside the container: - Authentication is shared with the host. If you've already run `claude login` / `codex login --device-auth` / `cursor-agent login` on the host, you're already authenticated in the container. - Plugins, skills, agents, memory, and settings sync both ways. Install a plugin in the container, it shows up on the host; add a custom agent on the host, the container sees it immediately. - All devcontainers on the host share the same CLI state, mirroring how host shells already share it. (Per-workspace isolation of plugins was never a stated requirement; the previous per-devcontainer named volumes leaked nothing useful.) Add `.devcontainer/ensure-host-config-dirs.cjs` and wire it as `initializeCommand`. It runs on the host before container create and guarantees `~/.claude`, `~/.codex`, `~/.cursor` exist, so Docker doesn't reject the bind mount when a CLI has never been used on this host. Cross-platform via Node `os.homedir()` + `fs.mkdirSync({recursive: true})`; idempotent; no third-party deps. Update `.devcontainer/README.md`: - New "How CLI state is shared with your host" section explaining the bind-mount model up front so users know their host plugins/skills/ memory carry into the container. - Mark first-time-login section as skippable when the user is already authenticated on the host. - Note the high-trust escape hatch: replace the three bind mounts with `type=volume` named volumes if the host/container trust boundary needs to be separated (Anthropic's reference pattern for enterprise). - Replace the obsolete "rm named volume" troubleshooting row with one that covers EACCES/EPERM on the host-bind-mount path. * refactor(devcontainer): address ce-code-review findings (P0 + 4 × P1 + 8 × P2 + 2 × P3) Walkthrough resolution of the 16-finding ce-code-review on PR #1875. 15 of 16 findings applied; one (F12, Anthropic Feature floating tag) was superseded by F6's Feature removal. P0 - F1: WSL2 is now REQUIRED for Windows hosts, not just recommended. ${localEnv:HOME} resolves to empty string on Windows-native (no HOME env var) — bind mounts then point at /.claude, /.codex etc. and silently break. ensure-host-config-dirs.cjs wrote to USERPROFILE-derived paths via os.homedir(), so the two surfaces disagreed about which env var was "home" on Windows. README header reframed; "Windows 11 — WSL2 is required" section explains the mismatch concretely. P1 - F2: Workspace `node_modules` volume names now include `-${devcontainerId}` so two GitNexus checkouts on the same host (~/work/GitNexus and ~/projects/GitNexus) don't share volumes and corrupt each other's installs. - F3 + F5: `postCreateCommand` extracted to `.devcontainer/post-create.sh` with `set -euo pipefail` and six labeled echo steps so failure logs name the step instead of an opaque &&-chain index. Chown step extended to cover /home/node/.npm, /commandhistory, and /home/node/.local — these named-volume mount points were owned by build-time UID 1000 but the container's `node` is re-IDed at runtime by updateRemoteUserUID on non-1000 Linux hosts, leaving them unwritable until now. - F4: Cursor installer downloaded to a temp file with curl --retry + --max-time; sha256 logged to build output before execution so drift across rebuilds is visible in CI logs. Full hard-pin (to a versioned downloads.cursor.com tarball with verified sha256) tracked as a follow-up in README "What's not included". P2 - F6: Anthropic Feature replaced with a direct `npm install -g @anthropic-ai/claude-code@${CLAUDE_CODE_VERSION}` so CLAUDE_CODE_VERSION actually pins the installed binary (the Feature ignored the ARG and pulled latest at install time). Honors the earlier "pin known-good versions" decision and resolves F12's floating-tag concern for this Feature. - F7: Dockerfile ARG defaults dropped for the three version vars; `devcontainer.json` `build.args` is now the single source of truth. Standalone `docker build .devcontainer/` must pass --build-arg. - F8: ensure-host-config-dirs.cjs deleted; `initializeCommand` now uses POSIX `mkdir -p` + `touch ~/.gitconfig` directly, dropping the host-Node-on-PATH prerequisite that broke on fresh Windows+Docker Desktop installs without Node. - F9: ~/.gitconfig bind-mounted read-only so `git commit` inside the container uses the host's user.name / user.email. Read-only so container-side `git config --global` doesn't leak to host. - F10: ~/.config/gh bind-mounted (read-write) so `gh pr create` / `gh pr checks` / `gh issue create` work inside the container without re-auth. AGENTS.md's commit + PR workflow now fully functional for agents inside the container. - F11: CLAUDE_CONFIG_DIR removed from Dockerfile ENV; canonical value lives only in devcontainer.json containerEnv. Eliminates the two-file edit risk. - F13: Mounts comment now documents per-instance vs per-workspace-name scoping rationale so future contributors don't guess. - F14: README "Trust boundary, concretely" paragraph names the exfil path explicitly (malicious npm postinstall → OAuth tokens → ~/.claude/projects/<workspace>/memory/MEMORY.md secrets) and lists vendor-side rotation runbook entries. P3 - F15: Dockerfile pre-create + chown of /home/node/.claude, .codex, .cursor dropped — those paths are bind-mounted, which fully shadows any image-side ownership. Only .npm, .local, /commandhistory still benefit from the pre-create. - F16: README "Bumping CLI versions" section rewritten against the post-F6 reality: CLAUDE_CODE_VERSION and CODEX_VERSION are real pins; CURSOR_VERSION is informational only. Verified locally: `docker build .devcontainer/ --build-arg ...` succeeds. Smoke-tested image: `claude --version` (2.1.153), `codex --version` (0.134.0), `cursor-agent --version` all resolve as the non-root `node` user; named-volume mount points (/home/node/.npm, /commandhistory) are node-owned at build time so non-1000 host UIDs get the post-create.sh chown fix instead of EACCES. * fix(devcontainer): cross-platform initializeCommand + soften Windows-native posture The previous commit's `initializeCommand` was POSIX-only (`mkdir -p $HOME/...`). VS Code on Windows runs the host shell as `cmd.exe /c ...`, which can't parse POSIX syntax — `$HOME` doesn't expand, `mkdir -p` errors, the init fails with `The syntax of the command is incorrect`, and container creation aborts before Docker is invoked. Switch `initializeCommand` to the spec's OS-keyed object form: - linux/darwin (covers WSL2 because VS Code runs initializeCommand in the WSL shell when attached via the WSL extension): POSIX mkdir+touch, as before - win32: PowerShell snippet that creates the same directories under $USERPROFILE and touches the gitconfig if missing Soften the README's hard "WSL2 required" framing from the previous commit. Reality per `@devcontainers/cli read-configuration` output: `${localEnv:HOME}` on Windows-native resolves to `C:\Users\<name>` (VS Code falls back to USERPROFILE), so the bind mount sources are valid Windows paths and Docker Desktop handles the translation. The earlier `accessing specified distro mount service` failure was a separate Docker Desktop WSL-integration issue, not a HOME-resolution issue. Windows-native works; it's just slower with more bind-mount permission edge cases (the husky/_/h EPERM class). The README now explains the tradeoff and steers toward WSL2 for performance + file watchers + permission reliability, rather than blocking Windows-native checkouts outright. Update the troubleshooting row to reflect the new posture. * fix(devcontainer): Node-based initializeCommand; bind-mount .ssh + .config/git Two fixes bundled: 1. The previous commit's OS-keyed `initializeCommand` object was based on a misread of the Dev Containers spec. The object form on command properties is **named parallel tasks**, not OS dispatch — VS Code ran all three keys in parallel via cmd.exe on Windows, the POSIX branches failed, and container creation aborted before Docker was invoked. Restore the single-string Node-based form: `node .devcontainer/ensure-host-config-dirs.cjs`. Node works identically in cmd.exe on Windows and bash/zsh on Linux/macOS/WSL, and `os.homedir()` respects $HOME on POSIX and %USERPROFILE% on Windows. The script is idempotent (mkdirSync recursive is a no-op for existing dirs; touch is gated on .gitconfig existence). Document Node ≥18 on the host as the only host-side prerequisite beyond Docker Desktop and the VS Code Dev Containers extension. Anyone running Claude Code on the host already has it. 2. Extend the host-bind mount surface with `~/.ssh` and `~/.config/git`, both read-only: - `~/.ssh` lets commit signing + push over SSH remotes work inside the container without copying private keys. Read-only mount means container code can read keys but can't modify or delete them. (Threat: a malicious dep can still read private keys from inside the container; the read-only mount narrows write-side blast radius, not read-side. Documented in the trust-boundary section.) - `~/.config/git` covers XDG-style git config (`~/.config/git/config`, `~/.config/git/ignore`, `~/.config/git/attributes`) for users who keep settings there instead of `~/.gitconfig`. Read-only, same as `~/.gitconfig`. Update the CLI-state-sharing table and trust-boundary paragraph to reflect the expanded surface. Re-adds .devcontainer/ensure-host-config-dirs.cjs (deleted before the OS-keyed attempt). * fix(devcontainer): fail-fast on Windows-native with HOME-not-set diagnostic The previous commit's "Windows-native works" softening was wrong. VS Code on Windows-native resolves `${localEnv:HOME}` by reading the host shell's HOME env var, and cmd.exe has no HOME set — the bind sources collapse to `/.claude`, `/.codex`, etc., and Docker errors: Error response from daemon: invalid mount config for type "bind": bind source path does not exist: /.claude The @devcontainers/cli output that prompted the softening was misleading because I ran it from a Bash session with HOME already set, not from VS Code's cmd.exe call context. The original Finding-1 P0 — that Windows- native silently breaks the bind-mount feature — was correct. Three changes: 1. `ensure-host-config-dirs.cjs` detects the failure mode early: `if (process.platform === 'win32' && !process.env.HOME)` prints a targeted error message naming the root cause (cmd.exe has no HOME → ${localEnv:HOME} resolves empty → bind sources fail) and a step-by-step pointer to set up WSL2. Exits 1 so VS Code surfaces it as a clean container-creation failure, not the cryptic Docker bind-mount error. 2. README header reverted to "Windows 11 via WSL2" only (not "and Windows-native"). The "Windows 11 — WSL2 is required" section names the specific HOME-resolution mismatch concretely so future readers understand why the constraint exists. 3. Troubleshooting table gets a new row for the `ERROR: GitNexus devcontainer requires WSL2` message pointing at the setup section. * feat(devcontainer): support Windows-native via auto setx HOME on first run Reverses the "WSL2 required on Windows" posture. Windows-native now works after a one-time auto-handled setup. The root cause of the bind-mount failure: VS Code resolves `${localEnv:HOME}` by reading its own process env, and Windows doesn't set `HOME` by default — Windows uses `USERPROFILE`. So the bind sources were collapsing to `/.claude`, `/.codex`, etc., and Docker rejected them. `ensure-host-config-dirs.cjs` now handles this automatically on Windows hosts where `HOME` is unset: 1. Runs `setx HOME "%USERPROFILE%"`, which writes to the user-level Windows environment (HKCU\Environment) — no admin required. Every future user process inherits HOME from there. 2. Prints a clear one-time setup banner explaining the user needs to fully restart VS Code (File > Exit, not just close the window) for VS Code to pick up the new env at its next startup. 3. Exits 1 so VS Code surfaces this as a clean container-create failure instead of letting Docker error opaquely later. On the second Reopen-in-Container attempt, `HOME` is now set in VS Code's env, the script skips the setup block, creates the bind-mount source dirs, and the container builds normally. Subsequent rebuilds have no extra steps. Mac, Linux, and WSL2 hosts have `HOME` set by the shell, so the new block is a no-op there. Same `devcontainer.json` works across all supported hosts. README rewritten to reflect the new posture: - Header lists Windows 11 (native) as a supported host alongside macOS, Linux, and WSL2, with a note that Windows-native gets a one-time HOME setup handled by the initializeCommand. - New "Windows 11 setup" section walks through the auto-handled setup flow + a manual `setx HOME "%USERPROFILE%"` fallback for users who want to do it themselves. - "Known trade-offs of Windows-native vs WSL2" subsection lays out the Docker Desktop Windows bind-mount edge cases (file watchers, npm install perf, husky/_ EPERM) so users opting into Windows-native do so eyes-open. WSL2 remains documented as the faster path for users who want it, but it's no longer the only supported one. - Troubleshooting table gets two new rows: the one-time setup banner (with "what to do" instructions) and the residual `bind source path does not exist` case (run setx manually + fully exit VS Code). * fix(devcontainer): drop ~/.gitconfig bind mount; defer to VS Code auto-copy VS Code's Dev Containers extension auto-copies the host's gitconfig into the container at attach time using `(dd ...) >> /home/node/.gitconfig`. A read-only bind mount of ~/.gitconfig blocks that write, so attach failed with `cannot create /home/node/.gitconfig: Read-only file system`. Making it read-write would let the append succeed, but the bind mount means the host file and the container file are the same file — VS Code's append would double the host gitconfig contents on every container start. Drop the ~/.gitconfig bind mount entirely. VS Code's auto-copy is the purpose-built mechanism for this, gives the container the host's user.name / user.email transparently, and avoids both the read-only write failure and the append-duplication trap. The container ends up with a writable /home/node/.gitconfig that's a copy of the host's, not a mount. The remaining six bind mounts (.claude, .codex, .cursor, .ssh, .config/git, .config/gh) keep their existing modes — XDG-style git config under ~/.config/git is unaffected by VS Code's auto-copy (which only targets ~/.gitconfig), so its read-only bind mount stays. Also remove the `.gitconfig` touch from ensure-host-config-dirs.cjs (now unnecessary) and update the README CLI-state table, sharing explanation, and troubleshooting row to reflect that gitconfig flows in via VS Code auto-copy rather than the bind mount. * feat(devcontainer): bind-mount ~/.docker, ~/.aws, ~/.azure for agent workflows Extend the host bind-mount surface so coding agents inside the container inherit cloud + container-registry auth from the host without any per-container setup: - ~/.docker (read-write) — Docker registry auth (config.json) + buildx config. Container-registry pushes (ghcr.io, docker.io) from inside the container pick up host `docker login` state. Read-write because the Docker CLI refreshes credential-helper tokens. - ~/.aws (read-only) — AWS CLI / SDK credentials. Read-only because rotating creds typically happens via the host. Empty on this dev box, so forward-compatible: the moment you `aws configure` on the host the container picks it up on the next rebuild. - ~/.azure (read-only) — Azure CLI credentials. Same pattern as ~/.aws. `ensure-host-config-dirs.cjs` extends to mkdir these three on init so the bind mounts always have a valid source even if a CLI has never been used on this host. The Docker CLI itself isn't installed in the container by default — the ~/.docker/ mount is inert until you add `docker-outside-of-docker:1` or similar Feature. README now calls this out under "What you still don't have inside the container" so it's obvious which CLIs are agent-ready and which need a feature add to become useful. README updates: - Bind-mount table gains a "Why" column and rows for the three new mounts, making it clear at a glance what each one enables. - Trust-boundary section lists Docker registry tokens, AWS, and Azure creds in the read-side exfil path so the threat model stays honest as the credential surface grows. - New subsection lists not-included CLIs (Docker, AWS, Azure, gcloud, kubectl, private-npm) with the exact Feature ID or mount snippet needed to enable each — turns "I want my agent to do X" into a one-line config change. Verified locally: `npx @devcontainers/cli read-configuration` resolves all 9 host bind mounts to valid C:\Users\<name>/* paths on Windows. * refactor(devcontainer): hybrid AI CLI config — read-only host share + per-container credentials Restructure the Claude Code / Codex / Cursor mount topology to fix the silent first-run-UI bug surfaced in PR testing, and to harden against the host-write-through escape class the previous bind-mount design exposed. The actual root cause of the first-run wizard firing on the user's screenshot — confirmed via three parallel research agents (best practices, framework docs deep dive of the OpenAI Codex Rust source, adversarial design review) — was NOT a credential permission check. Claude Code splits state across `~/.claude/.credentials.json` AND `~/.claude.json` (a FILE at $HOME, sibling of the `.claude/` dir). The latter holds `hasCompletedOnboarding`, `userID`, `oauthAccount` metadata, MCP user-scope config, and per-project trust state — and Claude Code reads it at literal `$HOME/.claude.json`, not via `CLAUDE_CONFIG_DIR`. The previous design mounted `~/.claude/` but left `~/.claude.json` outside the topology entirely, so every container started with a missing onboarding-state file and re-ran the wizard. Confirmed by tfvchow/field-notes-public#10: "Persisting .credentials.json alone is NOT sufficient. Without .claude.json, Claude Code treats the session as a fresh install and prompts for login regardless of valid credentials being present." The new topology: **Mounts** - `${localEnv:HOME}/.claude` → `/host/.claude` (read-only bind) - `${localEnv:HOME}/.codex` → `/host/.codex` (read-only bind) - `${localEnv:HOME}/.cursor` → `/host/.cursor` (read-only bind) - `${localEnv:HOME}/.claude.json` → `/host/.claude.json` (read-only bind) - `claude-config-${devcontainerId}` → `/home/node/.claude` (named volume) - `codex-config-${devcontainerId}` → `/home/node/.codex` (named volume) - `cursor-config-${devcontainerId}` → `/home/node/.cursor` (named volume) **containerEnv** gains `CODEX_HOME=/home/node/.codex` (Codex's own env override, per its public Rust source). `CLAUDE_CONFIG_DIR=/home/node/ .claude` was already set. **`post-create.sh`** stages the named volumes on first run: - Symlinks shareable subdirs from `/host/.claude` into the named volume: `plugins/`, `skills/`, `agents/`, `memory/`, `commands/`. Codex gets `config.toml` symlinked. Cursor has no shareable subdirs (cli-config .json conflates auth and settings). - Copies `.credentials.json`, `auth.json`, `cli-config.json` on first run with `chmod 600`. After first run, container manages its own refresh; host's credentials untouched. - Copies `~/.claude.json` on first run (with stub `{"hasCompletedOnboarding":true,"installMethod":"global"}` fallback for hosts that haven't run Claude Code). This is the fix for the observed onboarding-wizard loop. `ensure-host-config-dirs.cjs` now also touches `~/.claude.json` on the host if missing, so the bind mount has a valid source on hosts that have never run Claude Code. **Why read-only + named volume vs. the previous full bidirectional bind mount:** 1. **Host filesystem write-through escape, eliminated.** Previous design symlinked `plugins/`, `agents/`, `skills/` write-through into the host's `~/.claude/` — a malicious npm package in the workspace dep tree could drop `agents/evil.md` into the host's config, which the next host Claude session would auto-load. The read-only `/host` mount blocks this; container compromise no longer persists across teardown via host-side autoload. 2. **Windows bind-mount perm-flattening, sidestepped.** Files surfaced through a Docker Desktop Windows bind mount appear as `root:root` mode `777`. Credentials in the named volume come with proper Linux ownership and `chmod 600` — what each CLI expects on write (none enforces on read, but write-side hygiene matters for the host's understanding of "where credentials live"). 3. **No `ide/` lock-file collisions.** Previous design symlinked `~/.claude/ide/` write-through, including per-PID lock files. Host PID and container PID namespaces are unrelated → lock-file PIDs misclassify dead processes as alive. Skipping `ide/` keeps lock files container-local. 4. **No `projects/` ghost dirs.** Host encodes the workspace path as `D--development-coding-GitNexus`, container as `-workspace`. Bidirectional `projects/` symlinks would split memory and session state across two ghost project dirs for what is conceptually the same project. Skipping `projects/` keeps per-project state container-local; host's projects/ stays untouched. 5. **No `settings.json` version drift.** Container is pinned to a specific Claude Code version (`CLAUDE_CODE_VERSION` build arg); host floats with auto-update. Bidirectional `settings.json` writes produced silent schema rollback. Skipping settings.json keeps each side authoritative for its own version. **README** rewritten in the same section to describe the new topology honestly: what's shared, what isn't, the OAuth refresh-token divergence between host and container, per-CLI quirks (macOS Keychain storage, Cursor's known upstream in-container auth bug, Codex keyring storage). Trust-boundary section updated to name the threat model accurately — same read surface as before (malicious dep can still READ all credentials), but write-through into host plugin/agent dirs is now blocked. Verified locally: `@devcontainers/cli read-configuration` resolves all 19 mounts correctly on Windows, `post-create.sh` parses, and `ensure-host-config-dirs.cjs` idempotently touches `~/.claude.json`. Research backing this design: - Anthropic Claude Code devcontainer docs (named-volume pattern): https://code.claude.com/docs/en/devcontainer - tfvchow/field-notes-public#10 (both files required): https://github.com/tfvchow/field-notes-public/issues/10 - anthropics/claude-code#29029 (VS Code extension strips hasCompletedOnboarding): https://github.com/anthropics/claude-code/issues/29029 - OpenAI Codex Rust source (no read-side perm check): https://github.com/openai/codex/blob/main/codex-rs/login/src/auth/storage.rs - Cursor CLI in-Docker auth issue: https://forum.cursor.com/t/cursor-agent-authentication-issue-inside-docker/143995 * fix(devcontainer): resync AI CLI state from host on every container-create Two bugs were causing Claude Code to fire the onboarding wizard inside the container even with valid host credentials: 1. Missing the second state file. Claude Code 2.1.x writes a small `.claude.json` INSIDE `CLAUDE_CONFIG_DIR` (carrying migration tracking + userID), not just the one at `$HOME/.claude.json`. If the userIDs in the two files disagree, Claude treats the session as inconsistent and re-onboards. The previous post-create.sh only copied the `$HOME` one. 2. First-run guards (`[ ! -e $dst ]`) skipped the copy when stale named volumes from earlier rebuilds still had the prior session's state in them, leaving the container desynced from the host. Replace `copy_on_first_run` with `sync_from_host` that always overwrites from host on container-create. `link_readonly_share` now clears stale non-symlink dst entries before linking. Copies both `$HOME/.claude.json` and `$CLAUDE_CONFIG_DIR/.claude.json` so userIDs stay aligned. Container can still mutate its own state between rebuilds; resync only happens on rebuild (postCreate boundary). * docs(devcontainer): document sync-from-host design + dual-source auth flow README still described the old "first-run copy" behavior. After the post-create.sh change to always-sync-from-host, the design works either direction: - Log in on host → next container-create syncs the credentials into the named volume. - Log in inside the container → the named volume persists the login across rebuilds; the host has no source to overwrite from, so it stays alone. Also documents the two-Claude-state-files trap (`$HOME/.claude.json` AND `$CLAUDE_CONFIG_DIR/.claude.json`, both with the same userID required), and the volume-deletion recovery path for stale named volumes carried over from earlier rebuilds. * fix(devcontainer): full plugin/config parity by dropping CLAUDE_CONFIG_DIR + syncing settings.json Two changes that together give the container the same plugins and configs as the host for all three AI CLIs (login stays per-container): 1. Drop CLAUDE_CONFIG_DIR from containerEnv. The named-volume mount target `/home/node/.claude` already matches Claude's default `~/.claude`, so the env var added no behavior — but setting it changed which file Claude reads `hasCompletedOnboarding` from. With it set, Claude reads `$CLAUDE_CONFIG_DIR/.claude.json` (the small identity-only file that does NOT carry `hasCompletedOnboarding`); without it, Claude reads `$HOME/.claude.json` (the big onboarding-state file that does). The wizard fires every container-create when set, skips when unset. 2. Sync `settings.json` from host (Claude) + symlink `memories/` and `skills/` from host (Codex). Theme + `enabledPlugins` + `extraKnownMarketplaces` live in `settings.json` — without syncing it, the theme picker fires and host-installed plugins stay disabled even though their files are symlinked in. Codex's `memories/` and `skills/` are the symmetric Codex user-installed surface, now shared the same way Claude's plugins/skills/agents/memory/commands are. Cursor stays as-is — `cli-config.json` conflates auth+settings (already synced), and there's no separate plugin surface to mirror. Login details remain per-container by design (acceptable to re-login on rebuild). Everything else — plugins, skills, agents, memory, MCP user- scope config, project trust, theme, plugin enablement — now matches host on every container-create. * refactor(devcontainer): hybrid RW bind + per-container creds — fixes EROFS on in-container plugin install The previous Option B topology (RO host stage + named volume + symlinks into the volume) made `/plugin marketplace add` inside the container fail with EROFS — the symlinks pointed at a read-only mount, so Claude couldn't create new marketplace dirs. Switch to a hybrid: shareable content (plugins/skills/agents/memory/commands/settings.json/$HOME/.claude.json for Claude; config.toml/memories/skills for Codex) gets a direct RW bind from host so reads and writes go bidirectionally; credentials + the small identity file stay in per-container named volumes so logout in container doesn't log out host. Mount precedence does the heavy lifting: the named volume mounts at /home/node/.<cli> first, then sub-path bind mounts overlay specific sub-paths. Container's view at /home/node/.claude/plugins/ is the host dir; container's view at /home/node/.claude/.credentials.json is the named volume's file. What this gives you: - /plugin marketplace add in container = installed on host - New skill on host = visible in container immediately (no rebuild) - claude logout in container = host stays logged in - compound-engineering plugin enabled on host = enabled in container - Theme picker fires once (or never if host has theme set) What it costs: - Write-through: a compromised npm dep in workspace deps can write to host ~/.claude/{plugins,skills,agents,memory,commands}/. Documented trade-off; for personal dev, accepted. Credentials still per-container. post-create.sh becomes much simpler — only syncs the four credential files from host into the named volumes. No more symlink dance, no more state-file merging. ensure-host-config-dirs.cjs gains the new bind sources: the shareable subdirs and settings.json/config.toml files get mkdir/touched on host so Docker doesn't reject the mount when a CLI has never been used. * fix(devcontainer): translate host plugin registry paths to Linux on rebuild The previous topology bind-mounted the entire `~/.claude/plugins/` directory from host. That brought through plugins, marketplaces, and extracted cache content correctly — but ALSO brought through the registry JSONs (`known_marketplaces.json`, `installed_plugins.json`, `plugin-catalog-cache.json`) which carry absolute OS-native paths: "installLocation": "C:\Users\gergo\.claude\plugins\marketplaces\X" "installPath": "C:\Users\gergo\.claude\plugins\cache\Y\Z" Claude in the Linux container fails to resolve these Windows paths and reports `Marketplace X failed to load: cache-miss`. Split the topology: - `plugins/marketplaces/` (git clones) and `plugins/cache/` (extracted plugin files) stay bidirectional RW binds — content is path-independent. - Registry JSONs move into the per-container named volume. post-create.sh reads host's versions, rewrites any absolute path ending in `/.claude/plugins/<rest>` (Windows `C:\Users\...` and POSIX `/Users/...` / `/home/...` patterns) to `/home/node/.claude/plugins/<rest>`, and writes the translated result to the volume. What this gets you: - Plugin installed on host → next container rebuild has it (translated). - Plugin installed inside container → lives in volume registry; lost on rebuild (consistent with credentials model). Re-install on host for persistence. ensure-host-config-dirs.cjs now also creates `plugins/marketplaces/` and `plugins/cache/` on host if absent (Docker rejects bind mounts whose source doesn't exist). * fix(devcontainer): clean stale plugin/skill symlinks from prior design before writes A user upgrading from Option B (read-only host stage + symlinks) to the current hybrid RW-bind topology hit EROFS in post-create.sh when the plugin registry path-translator tried to write `/home/node/.claude/plugins/known_marketplaces.json`. The named volume still carried `/home/node/.claude/plugins -> /host/.claude/plugins` (Option B's symlink). The new design's sub-path bind mounts at `plugins/marketplaces` and `plugins/cache` overlay through the symlink, but writes to the parent dir itself resolve via the symlink to the RO host stage and fail. Drop any leftover symlinks at known target paths early in step 2 so the mkdir/writes that follow land in the volume. * refactor(devcontainer): split workspace-deps to updateContentCommand post-create.sh was doing two unrelated jobs: workspace dependency install (four `npm install` runs in topological order) and AI CLI credential sync. They have different lifecycle needs — deps should re-run when lockfiles change, AI sync should run once per container — but both were gated on container-create. Per Dev Container spec lifecycle, `updateContentCommand` is the right hook for workspace deps: runs at container-create AND on content changes (lockfile updates). `postCreateCommand` is right for AI CLI sync: container-create only. Move steps 3-7 (husky cleanup + four `npm install` runs) into install-deps.sh wired as `updateContentCommand`. Split the chown step too — install-deps owns workspace-side dirs (node_modules volumes, ~/.npm), post-create owns AI-side dirs (~/.claude, ~/.codex, ~/.cursor, /commandhistory, ~/.local). Each script now has one concern. post-create.sh drops from ~187 lines to 148; install-deps.sh is 56 lines new. Faster rebuilds when nothing about deps changed (the credential sync + path translation work still runs every container-create, but the npm install dance no longer does). Research backing (no other simplification applies): - Anthropic's reference devcontainer uses pure named volumes; no host-state inheritance pattern is published. - Path translation has no upstream fix (issues #21916, #10379 closed without resolution). Our Node rewrite is the workaround. - pnpm workspaces (`pnpm -r install`) would replace the four installs with one command, but that's a real refactor (touches gitnexus/scripts/build.js + 4 package.json files); deferred. - `HUSKY=0` in containerEnv would drop the `rm -rf .husky/_` hack, but would also stop pre-commit hooks from firing inside the container; deferred. * fix(devcontainer): drop single-file binds — fixes Codex `batchWrite failed in TUI` On Docker Desktop Windows the named volumes are ext4 (`/dev/sdd`) while single-file bind mounts from the Windows host land as 9p (drvfs). Different filesystems → atomic config writes (write `foo.tmp`, then rename onto `foo`) trip EXDEV `inter-device move failed` / `Device or resource busy`. Codex's TUI surfaces this as `config/batchWrite failed in TUI` when saving model preference. Claude's writes to settings.json / .claude.json fail the same way, silently. Reproduction in container: $ echo x > /tmp/foo.toml; mv /tmp/foo.toml /home/node/.codex/config.toml mv: inter-device move failed: ... Device or resource busy Fix: drop the three single-file bind mounts. Sync host's versions into the named volume on container-create via `sync_from_host` (same pattern already used for credentials). Atomic rename within the volume works because everything is ext4. Trade-off: container writes to these files no longer propagate to host; they stay in the volume until next rebuild, which re-syncs from host. Host is source of truth on rebuild — same model as credentials. Plugin/ skill/agent/memory/command DIRS still bind-mount bidirectionally (atomic writes within a dir bind stay on one filesystem, no EXDEV). Files affected: - ~/.codex/config.toml - ~/.claude/settings.json - ~/.claude.json (HOME-level — added `/host/.claude.json` RO mount back for sync_from_host to read) * chore(autofix): apply prettier + eslint fixes via /autofix command * feat(devcontainer): Codex + Cursor plugin/config host parity with Claude Codex plugins installed in the container never reached the Windows host because, unlike Claude, the Codex plugin tree wasn't bind-mounted — only memories/ and skills/ were. Verified via live /proc/mounts: Claude binds 6 shareable dirs (incl. plugins/marketplaces + plugins/cache), Codex bound 2. So `codex plugin add` wrote into the ext4 named volume and stayed there. Codex changes: - Bind the WHOLE ~/.codex/plugins dir + ~/.codex/prompts (plus existing memories/skills). Strace of two real `codex plugin add` runs proved the installer stages INSIDE plugins/cache/<marketplace>/ and renames intra-dir, so a single 9p bind of plugins/ keeps the rename intra-fs — no EXDEV (the bug that broke single-file binds). .tmp/ stays on the volume (it's the cross-fs staging source). No path translation needed: Codex enablement lives in config.toml as git URLs, not FS paths. - Verified live: `codex plugin add compound-engineering@...` now writes through to C:\Users\...\.codex\plugins\cache\ on the Windows host, and host-created files appear in the container (bidirectional). Cursor changes (review found cursor-agent has a real plugin surface, not editor-only — Cursor 2.5 Marketplace shared by IDE + CLI): - Bind plugins/marketplaces, plugins/local, rules, commands, agents, skills (dir binds, EXDEV-safe). - Copy-on-create mcp.json (single file → EXDEV-unsafe as bind), alongside the existing cli-config.json. - Translate plugins/installed_plugins.json (carries absolute Windows paths like Claude's) — generalized the existing path-rewrite to run for both Claude and Cursor. - hooks.json deliberately NOT shared (runs shell commands → supply-chain surface); documented as opt-in. ensure-host-config-dirs.cjs pre-creates all new host bind sources. post-create.sh defensive symlink cleanup extended to the new Codex/Cursor paths. README updated with the accurate per-CLI share/sync/translate matrix. Design adversarially verified (straced installs, EXDEV primitive tests, sqlite-under-bind check, path-encoding check) before implementing. * fix(devcontainer): resolve ce-code-review findings (doc drift, chown scope, .cjs extraction, CI smoke) Multi-agent review (9 reviewers) found the devcontainer files carried comments + README from the abandoned read-only-symlink design, plus real behavioral gaps. Resolved all actionable findings (no deferrals). Documentation drift (the headline — stale comments described a security model opposite to what shipped): - README "Trust boundary" claimed a malicious dep "cannot write back … the read-only /host mount blocks the write." FALSE — the shareable dirs are RW-bound. Rewrote to document the bidirectional write-through, what stays one-way (credentials never flow back), and how to close it. - devcontainer.json mount group-1 comment described "selectively symlinks … read-only eliminates write-through" — replaced with the RW-bind reality. - Header "Windows-native is unsupported" -> supported (auto HOME setup). - containerEnv comment "credentials persist in host-bind-mounted dirs" -> they live in the named volumes. - hooks.json exclusion documented honestly as a partial mitigation, not a clean boundary (commands/agents/skills/rules are equally executing). - ~/.local "named volume" -> image directory. Behavioral fixes: - chown -R recursed into the RW host binds (could rewrite host ownership / EPERM-abort provisioning on non-UID-aligned Linux). Switched to `find -xdev` per dir so chown stays on the volume filesystem. - Cursor installer wrapped in `timeout 300` — its inner binary download isn't covered by curl --max-time and could hang docker build forever. - Removed dead CURSOR_VERSION ARG/ENV/build-arg (never consumed; "latest" implied a pin the installer can't honor). Documented why Cursor is unpinned. Extraction + tests (the two inline post-create.sh node heredocs were unlintable and untestable; the path regex had had bugs): - seed-claude-config.cjs — installMethod-strip seed, now with a non-object guard (a bare-value/array host .claude.json could otherwise slip the try/catch and silently re-trigger onboarding) and labeled write errors. - translate-plugin-registries.cjs — plugin-registry path translation with labeled errors. - translate-plugin-registries.test.cjs — 12 tests (Windows/POSIX paths, cross-CLI isolation, nested objects, non-object/empty-config guard). - post-create.sh calls the modules via $SCRIPT_DIR. CI: - .github/workflows/ci-devcontainer.yml — runs the unit tests + shell syntax checks + a `@devcontainers/cli build` smoke on .devcontainer/** changes. Conforms to the repo concurrency convention (validator passes). Documented (real gaps, fixes are honest docs since no correct auto-fix exists): user-scope MCP servers with absolute host command paths don't resolve in-container; user-scope config is copy-on-create so host edits need a rebuild; in-container plugin installs get shadowed by an empty host bind on rebuild (recovery noted); plugin installs are single-writer across checkouts; gh/docker RW-vs-ssh/aws/azure-RO rationale. Verified: fresh `@devcontainers/cli up` succeeds; installMethod stripped, registry translated to Linux paths, credentials node:node, 12/12 tests pass. * fix(devcontainer): set persist-credentials:false on CI checkouts + prettier - zizmor `artipacked` (CodeQL/GitHub Advanced Security) flagged both actions/checkout steps in ci-devcontainer.yml: checkout defaults to persist-credentials:true, leaving GITHUB_TOKEN in .git/config where it can leak into uploaded artifacts. Both jobs are read-only (run tests / build smoke, never push), so persist-credentials:false is correct — matches the repo convention in codeql.yml / ci-tests.yml. - Ran prettier 3.8.0 over the new .cjs modules + test (single-quote/style normalization to match the repo). JSON/YAML were already compliant; README is in .prettierignore; .sh has no prettier parser. Behavior unchanged — 12/12 transform unit tests still pass. * fix(devcontainer): resolve adversarial review findings (pins, RO mounts, tests) Resolves the blocking + actionable findings from the PR #1875 review: - Pin base image by digest as bare name@digest [#1]. The :tag@digest form trips the @devcontainers/cli image-name parser (which builds this image in CI and in VS Code "Reopen in Container"); bare name@digest is the parser-compatible form. Verified by a full local build. - Pin Cursor by version + per-arch sha256 and fetch the artifact directly instead of executing cursor.com/install; fail-closed on mismatch [#2]. - Mount ~/.config/gh and ~/.docker read-only so a compromised dep can't rewrite the host GitHub token / Docker credHelper [#4]. - Pin @devcontainers/cli@0.87.0 in the CI smoke [#5]. - chown via find -xdev in install-deps.sh (symlink-safe; matches post-create.sh) [#6]. - Add filesystem-I/O tests (translate/readHostConfig/seed main/ensurePaths) and refactor ensure-host-config-dirs to be unit-testable [#7]. - Stop pre-creating settings.json/config.toml on the host; only the real single-file bind source (.claude.json) is touched [#10]. - Add a prominent top-of-README security callout for the RW write-through trade-off and reframe the deferred egress firewall as the key missing compensating control [#3, #9]. Full devcontainer build verified locally (digest pull + pinned Cursor download/extract/symlink). 24/24 config-transform tests pass. * fix(devcontainer): resolve local adversarial-review findings (low/nit) Follow-up to a local branch review (run after the cloud review crashed before producing findings); all 5 confirmed findings were low/nit: - chown via `find -xdev -exec chown -h`: add -h so chown acts on a symlink ITSELF, not its target. Without it a dangling node_modules/.bin link aborted provisioning under `set -e`, and a cross-fs symlink target could be dereferenced/rewritten. Verified in a clean container (regular files still chowned; dangling link no longer aborts; cross-fs target untouched). Applied to install-deps.sh and post-create.sh; the inline comments are corrected to describe -xdev (descent bound) and -h (no deref) as the two distinct guards. - Reword the .cjs header claims from "lintable" to "unit-tested and prettier-checked": ESLint applies no rules to .cjs in this repo; CI only prettier-checks them. - README: the initializeCommand is `node ensure-host-config-dirs.cjs`, which creates the full bind-source set, not a bash `mkdir -p` of four dirs. - ci-devcontainer.yml: document that the x64 runner exercises only the amd64 Cursor branch; the arm64 sha/URL is hash-pinned (verified against the published artifact) but not built in CI. - Make the seed chmod-644 test meaningful: pre-create dst at 0o600 so only the explicit chmodSync can widen it (the prior assertion passed under the default umask regardless of whether the chmod ran). 25/25 config-transform tests pass; arm64 + x64 Cursor artifacts verified. * docs(devcontainer): rewrite code comments in plain English The devcontainer comments had grown dense and jargon-heavy. Rewrite them across all 9 files into short, plain-English sentences — same facts and reasoning, just clearer wording. Comments only; no code changed. Verified: the diff touches comment lines only, 25/25 config-transform tests pass, devcontainer.json is still valid JSONC with build.args + readonly mounts unchanged, shell scripts pass `bash -n`, and prettier is clean. * feat(devcontainer): persist AI CLI session state across container recreation Add dedicated per-workspace named volumes (mount group 6) for the three AI CLIs' session/resume state so `claude --resume`, `codex resume`, and `cursor-agent resume` survive a rebuild, a full delete-and-recreate, and the `docker volume rm <cli>-config-*` re-login fix: - Claude -> ~/.claude/projects - Codex -> ~/.codex/sessions - Cursor -> ~/.cursor/chats + ~/.cursor/projects The volumes are SEPARATE from the credential/config volumes and keyed like the node_modules volumes (${localWorkspaceFolderBasename}-...- ${devcontainerId}), so wiping a config volume to force a re-login no longer destroys session history. Session state already survived a plain rebuild (it lived in the config volume); this closes the recreation, volume-rm, and devcontainerId-change gaps. Kept container-private (not host bind mounts) deliberately: transcripts can contain pasted secrets, so a host bind would spill them to host disk, widen the supply-chain write-through surface, and leak cross-project transcripts. A commented-out opt-in host-bind block is included for users who accept that trade-off. post-create.sh: chown each new volume root explicitly (find -xdev stops at the config-volume filesystem boundary and won't descend into them), guarded with `[ -d ] || continue` so a missing root can't abort provisioning under set -e. README: document the topology, what survives vs not, the one-time first-rebuild masking of pre-existing config-volume sessions, updated rebuild/reset commands, and the trust-boundary impact. * feat(devcontainer): isolate host AI-CLI config via seed-once copies + persist claude-mem Replace the read-write host bind mounts for the AI-CLI shareable dirs (Claude skills/agents/memory/commands/plugins; Codex plugins/prompts/ memories/skills; Cursor rules/commands/agents/skills/plugins) with a seed-once copy from a read-only /host/.<cli> stage into the per-container config volume. The container gets its own writable copy and can never write back to the host, closing the write-through vector where a compromised in-container dependency could drop a malicious agent, command, skill, or plugin onto the host for the next host session to auto-load. Add a per-container claude-mem named volume (claude-mem-${devcontainerId}) at /home/node/.claude-mem, seeded once from a read-only /host/.claude-mem stage. claude-mem's multi-GB SQLite + Chroma store is kept off a host bind (unreliable fcntl locking / corruption risk over 9p on Docker Desktop Windows) while still surviving rebuilds. - post-create.sh: seed shareable dirs (marker-gated, seed-once) and run plugin-registry translation per seeded CLI; seed claude-mem behind a completion-sentinel guard that self-heals an interrupted multi-GB copy; chown the claude-mem volume only on first create. - translate-plugin-registries.cjs: add selectRegistries() so translation runs per-CLI seed-once instead of clobbering container-installed plugins. - ensure-host-config-dirs.cjs: add ~/.claude-mem; drop the shareable subdirs (no longer bind sources). - devcontainer.json: drop the RW shareable binds; add the claude-mem volume + read-only stage. - README: rewrite trust-boundary, mount table, and rebuild/reset docs for the copy model. - tests: cover selectRegistries and the trimmed DIRS (30 pass). * feat(devcontainer): add Bun 1.3.14, pinned via build arg Installed by the official bun.sh/install script with the release tag passed as the first positional arg, so the version is pinned even though the install path itself is an unverified remote script (the one such exception in the image — Cursor and the base image stay sha256/digest- pinned). BUN_INSTALL is set in ENV so the binary lands at a known path and the installer's rc-file edits don't matter. unzip is added to apt since the Bun installer extracts a .zip. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(devcontainer): persist gh auth via copy-into-volume model Move ~/.config/gh from a read-only bind to the same read-only host stage + per-container named volume pattern used for the AI CLI credentials. post-create.sh seeds hosts.yml/config.yml from the /host/.config/gh stage into the gh-config volume on create, so an in-container `gh auth login` now persists across rebuilds while the read-only stage still prevents any write-back to the host token. Co-authored-by: Cursor <cursoragent@cursor.com> * fix(devcontainer): bump Claude Code to 2.1.156 for Opus 4.8 The pin was 2.1.153, which predates Opus 4.8 support (added in 2.1.154). With DISABLE_AUTOUPDATER=1 the container never updated past the pin, so Claude Code only offered models up to 4.7. Bump to the latest 2.1.156 so Opus 4.8 is available. Co-authored-by: Cursor <cursoragent@cursor.com> --------- Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com> Co-authored-by: Cursor <cursoragent@cursor.com>	2026-06-02 05:09:01 +01:00
Gergő Magyar	83fbd4be26	refactor(ci): unify release pipeline under publish.yml (#1610) ... Collapse release-candidate.yml into publish.yml so there is exactly one workflow that publishes gitnexus to npm, creates GitHub Releases, and triggers Docker builds — for both release candidates and stable releases. Closes #1609 architecturally. A first-stage `route` job classifies push-to-main / push-tag / workflow_dispatch into `rc` / `stable` modes and fails closed on malformed shapes. RC path runs rc-guard → ci.yml → publish (mint GitHub App token → checkout with persist-credentials:false → resolve next rc version → atomic v-tag + rc/<SHA> marker push → vtag integrity gate → npm publish via OIDC → GitHub prerelease → if: failure() cleanup) → docker.yml. Stable path verifies package.json matches the tag and publishes to `latest` via OIDC (no docker). Hardening: • Self-trigger prevention via negative-glob `tags: ['v*', '!v*-rc.*']` — the bug class behind #1609 cannot recur. • Two distinct actions/checkout steps per mode (no conditional `token:` expression footgun). • Workflow-level `permissions: {}` deny-all + per-job grants; `id-token: write` only where OIDC is used. • npm Trusted Publishing replaces NPM_TOKEN (delete the secret after the first successful publish). • GitHub App installation token (actions/create-github-app-token@v3.2.0) replaces the long-lived RELEASE_PUSH_TOKEN PAT (delete after first successful RC). • vtag integrity gate fails closed on empty / mode-mismatched output (prevents Release named `main` from a github.ref fallback). • Annotation-injection sanitization on every logged ref. • Explicit `secrets:` passthrough on docker.yml (DOCKERHUB_USERNAME, DOCKERHUB_TOKEN); ci.yml no longer inherits anything. • `if: failure()` cleanup auto-deletes v-tag + rc-marker on partial failure (eliminates the external-consumer phantom-version ingestion window). • ACTIONS_STEP_DEBUG window closed via `set +x` wrap on the inline auth-header compute. • Curated retry-loud error handling on `gh api` bot-user-id lookup and `npx semver`. Pre-merge validation: • 10-reviewer multi-agent code-review pass; 14 findings fixed inline (commit 820cefae), 6 deferred to follow-ups. • End-to-end dry-run rehearsal via workflow_dispatch (run 25919563064) validated route classification, rc-guard, App token mint, RC checkout, version resolver, vtag synthetic-regex check, and faithful tarball pack at the bumped version. • All zizmor findings on the unification commits closed. • Branch-protection required checks all green. Post-merge actions: • After the first successful RC, delete the `NPM_TOKEN` and `RELEASE_PUSH_TOKEN` secrets — they are no longer used. • The first real RC after merge is the live-fire test for steps dry-run could not exercise (atomic tag push, real npm OIDC handshake, GitHub Release creation, docker.yml under explicit secrets passthrough). The if: failure() cleanup step handles the partial-failure recovery automatically; the Rollback Runbook in CONTRIBUTING.md covers the rare cases auto-cleanup can't reach.	2026-05-16 07:46:56 +01:00
Gergő Magyar	6906be3695	feat(autofix): replace inline reviewdog with /autofix ChatOps button (#1458) ... * fix(autofix): verify reviewdog actually posted before claiming "click Apply" The sticky summary comment was stating "Posted formatting suggestions inline. Click Apply suggestion on each" even when reviewdog landed zero inline review comments — typical case: the formatter touched lines outside the PR's added range, so `-filter-mode=added` (correctly) filtered everything out. The script unconditionally set `posted=true` after running reviewdog regardless of whether any comments were actually created, leaving the user staring at a sticky that promised buttons that didn't exist. The publish job now snapshots the count of `github-actions[bot]` review comments before and after reviewdog. If the delta is zero, surface a new `diff-no-overlap` UI state that tells the user plainly: "Formatter found fixable issues, but they're on lines outside this PR's added range — there's nothing to click here. Run locally: npm run lint:fix && npm run format." Plus a matching `gitnexus/autofix` Check Run conclusion (still neutral, distinct title) so agents reading `gh pr checks` see the same signal. Three states are now machine-distinguishable in the sticky's gitnexus-autofix JSON block: suggestions-posted (delta > 0), diff-no-overlap (delta == 0), skipped-too-large (>3k lines). * feat(autofix): replace inline reviewdog with /autofix ChatOps button Pivot the PR autofix UX from per-line reviewdog suggestions to a single slash-command button. Contributors comment `/autofix` on the PR; a new trusted workflow downloads the existing autofix patch artifact, applies it to the PR head, and pushes a commit back. Why: - 3K+ diffs hit GitHub's review-comment API 406 limit -> dead end. - Diffs where the formatter touches lines outside the PR's added range ("no-overlap") get filtered by reviewdog's -filter-mode=added -> dead end (PR #1457 patched the lying sticky but the underlying UX gap remained). - Per-line click-Apply-suggestion is high-friction for big diffs and easy to apply unevenly. - A single `git apply` + push works at any size and lands fixes atomically. Changes: - pr-autofix-publish.yml: remove `Install reviewdog` and `Post inline suggestions` steps. Collapse three sticky states (suggestions-posted, diff-no-overlap, skipped-too-large) into one (fixes-available). Bump JSON schema v1 -> v2 with `apply_command` field; all v1 fields preserved. - pr-autofix-apply.yml (new): triggers on issue_comment with body `/autofix`, validates body via strict regex, validates commenter has write/admin/maintain or is the PR author, locates latest successful pr-autofix run for PR head SHA, downloads artifact, applies patch, pushes commit. Reacts +1/-1/eyes on triggering comment per outcome. Idempotent (`git apply --check --reverse` detects already-applied state). - CONTRIBUTING.md: document v2 schema and the /autofix flow, including the maintainer-edit requirement for fork PR pushes. Trust posture: apply workflow runs from default-branch code only, under issue_comment trigger. Comment body and author login flow through env vars and pattern-matched, never interpolated into shell. Permission gate (write/admin/maintain OR PR author) before any artifact fetch. Fork PRs require "Allow edits by maintainers" (GitHub-native; we don't bypass). Net YAML: -139 lines in publish.yml, +260 in apply.yml. Removes reviewdog binary pin and the entire review-comment API surface. * fix(autofix): address Codex adversarial findings on PR #1458 Two findings from the Codex adversarial review of the autofix ChatOps pivot. Both are localized YAML changes that close trust gaps the pivot inherited from the original PR #1446 design. U1 — Cross-verify metadata against workflow_run authority (.github/workflows/pr-autofix-publish.yml): Previously the trusted publisher accepted pr_number, head_sha, and head_repo from metadata.json after only an allowlist regex. A fork-controlled `npm run lint:fix` could have written a syntactically valid metadata.json referencing another PR/SHA, redirecting the write-scoped sticky/check-run onto an attacker-chosen target. New `Verify metadata against workflow_run authority` step compares artifact-claimed identity against: - github.event.workflow_run.head_sha - github.event.workflow_run.head_repository.full_name - workflow_run.pull_requests[].number (within-repo PRs) - gh api commits/{sha}/pulls fallback (fork PRs, where pull_requests[] is empty) Fail closed on mismatch — no sticky, no check-run, no override. U2 — Lease-protected push in apply workflow (.github/workflows/pr-autofix-apply.yml): Previously the apply step pushed `HEAD:${HEAD_REF}` plain. A force- push between resolve (Step 5) and push (Step 9) would silently fast-forward an older commit graph over the contributor's newer state. Push now uses `--force-with-lease=refs/heads/${HEAD_REF}:${HEAD_SHA}` against the SHA resolved earlier. Distinct `lease-failed` result code + retry-message reply, separated from `push-failed` (fork without maintainer-edit) so contributors can diagnose the actual cause. Plan: docs/plans/2026-05-09-005-fix-autofix-codex-adversarial-findings-plan.md (local-only per repo convention). Trust posture preserved: no new permissions, no new workflows, no contract change. JSON v2 schema unchanged. CodeQL js/server-side- request-forgery and template-injection posture unchanged — all new inputs flow via env vars and pattern-matched. * fix(autofix): close zizmor credential-persistence finding on apply checkout actions/checkout's default behavior writes the GITHUB_TOKEN into .git/config as an extraheader. The token then sits on disk in the checkout directory — an actions/upload-artifact step on that directory would leak it. We don't upload, but zizmor's credential-persistence lint correctly flags the latent risk. Set persist-credentials: false on the Checkout PR head step. Provide push auth inline via `git -c http.extraheader="Authorization: Basic <base64-of-x-access-token:TOKEN>"` so the credential never lands on disk and never appears in process listings (the URL form https://x-access-token:TOKEN@… is rejected here because it leaks via ps and git remote -v). Push lease semantics from U2 unchanged — same --force-with-lease against the resolved HEAD_SHA, same lease-failed/push-failed/stale result codes. * fix(review): apply autofix feedback ce-code-review surfaced 15 findings on PR #1458; this commit applies the 7 with concrete fixes (#1, #2, #3, #4, #5, #9, #13). Five P2 findings (#6, #7, #8, #10, #12) are recorded as residual actionable work for follow-up; two advisory items (#11, #14) skipped. #1 — applied_run_id schema drift (CONTRIBUTING.md): v2 docs claimed `state: applied` enum value and an `applied_run_id` field that no code path emits. Trimmed docs to match what the workflow actually writes (state: fixes-available; v1 field set as superset). Implementing the apply-side sticky upsert that would populate `applied_run_id` is deferred — cleaner than carrying a contract claim with no code. #2 — result= unset between idempotency probe and lease push (pr-autofix-apply.yml): After `git apply --check` passed, an early non-zero exit from `git config` / `git apply` / `git add` / `git commit` left `result=` unset, sending the user to the `*` "unexpected state (`unknown`)" arm. Wrapped the apply/commit phase in a single if-test that sets `result=apply-failed` on any failure. New React-and-reply branch surfaces an actionable message. #3 — permission lookup conflated transient API failures with denial (pr-autofix-apply.yml): `gh api … 2>/dev/null || echo "none"` swallowed 5xx, 429 secondary rate-limit, and network failures, surfacing them as a public 👎 refusal to legitimate maintainers. Now distinguishes 404 (genuine non-collaborator) from other API failures via stderr match. New `allowed=api-failed` state triggers a 😕 reaction with a "transient API failure, retry" reply instead of a misleading refusal. #4 — lease-failure grep missed git's "remote rejected" / branch- deleted phrasings (pr-autofix-apply.yml): Real lease failures got classified as `push-failed` → user told to enable maintainer-edit, which won't help. Expanded regex to match `remote rejected` and `! [rejected]`. #5 — broken bullet continuation in CONTRIBUTING.md release-candidate section: rejoined the split bullet so it renders correctly. #9 — base64 GITHUB_TOKEN bypassed GitHub's secret-masker (pr-autofix-apply.yml): Added `::add-mask::${auth_header}` immediately after construction so any subsequent log line (set -x, GIT_TRACE) gets *** redacted. #13 — misleading schema-bump comment in pr-autofix-publish.yml: Comment claimed all v1 fields preserved exactly, but the `state` enum was redefined v1→v2. Updated to make the migration path explicit (v1 readers see unfamiliar schema, fall back to prose). Residual actionable work (deferred to follow-up): #6 locate step gh api retry; #7 artifact-expired graceful fallback; #8 re-entrancy comment-spam guard; #10 producer-still-running UX; #12 gh_retry wrapper for apply.yml. Validations: yaml.safe_load OK, check-workflow-concurrency.py OK. * fix(autofix): apply remaining ce-code-review residual findings (#6, #7, #8, #10, #12) Pulls the deferred items from the previous review pass into this PR so the workflow ships with full reliability + UX coverage rather than follow-up debt. #6 + #12 — gh_retry wrapper on idempotent GETs in apply.yml: Permission lookup, PR metadata fetch, and workflow-run lookup are now wrapped in the same gh_retry helper publish.yml uses (3 attempts, linear backoff). Reaction/comment POSTs remain unwrapped (retrying POST would dupe the resource). #10 — producer-still-running UX: The locate step now distinguishes three cases via `found_status` output: success (proceed), in-progress / queued / pending / waiting (reply ⏳ "wait for autofix run to finish"), not-found (reply 🤔 "push a commit"), api-failed (reply ⚠️ "transient API failure"). The "no successful autofix run" message no longer fires immediately after a fresh push while the producer is still mid-run. #7 — artifact-expired graceful fallback: actions/download-artifact gains `continue-on-error: true`. The apply step distinguishes patch-file-missing (artifact expired, 1-day retention elapsed) from patch-file-zero-bytes (formatter found nothing). New `result=artifact-expired` case + ⏳ "push a new commit to regenerate" reply. #8 — re-entrancy loop guard: After checkout but before applying, check if HEAD itself is a github-actions[bot] `chore(autofix)` commit. If so, refuse to re-apply (`result=loop-prevented`) with a 🔁 reply telling the user to push a human-authored commit or revert before retrying. Prevents formatter-config-drift loops where an automated agent watching the sticky could pump arbitrary apply commits. Net effect: every code path in apply.yml now sets a meaningful `result=` that maps to a specific user-facing reaction + reply. The `*` "unexpected state (unknown)" arm becomes truly unreachable in normal operation. Validations: yaml.safe_load OK, check-workflow-concurrency.py OK. * fix(autofix): refresh stale reviewdog comments + reject patches touching .github/ Two follow-up findings on PR #1458: #1 — Stale reviewdog references in workflow header comments: pr-autofix-publish.yml's header still described the removed inline- suggestion path ("posts inline review-comment suggestions to the PR using `reviewdog`", "Reviewdog reporter: github-pr-review reads $REVIEWDOG_GITHUB_API_TOKEN…"). The Check Run permissions comment enumerated the old outcomes (clean / suggestions-posted / skipped-too-large) instead of the current set (clean / fixes- available). pr-autofix.yml's header described the trusted job as posting "inline review-comment suggestions" and the changed_lines comment referenced the dead 3000-line cap. Refreshed all three to describe the actual sticky + Check Run + /autofix flow. #2 — Reject patches touching .github/ (sensitive-paths guard): Theoretical supply-chain vector: a malicious PR could ship a custom prettier/ESLint config that reformats workflow YAML, dependabot.yml, or CODEOWNERS. The producer would capture those edits in autofix.patch; a maintainer running `/autofix` would push them under `contents: write` without human review. The default GITHUB_TOKEN lacks the `workflows` scope so workflow-file pushes would fail at the platform layer anyway, but as a generic `push-failed` (which misleads users into enabling maintainer-edit). Reject early with a specific reason. Match runs against the patch with grep on `^(diff --git|---|+++) [ab]?/?\.github/`. New `result=sensitive-paths` case + 🛑 reply telling the user to apply .github/ formatter changes manually. Documented the constraint in CONTRIBUTING.md under the /autofix section so contributors aren't surprised when the workflow refuses a patch that includes formatter changes to workflow files. Validations: yaml.safe_load OK, check-workflow-concurrency.py OK.	2026-05-09 16:32:38 +01:00
Gergő Magyar	b5627f27d8	ci: add fork-safe PR autofix pipeline (#1446) ... * ci: add fork-safe PR autofix pipeline Two-workflow split posts prettier + eslint --fix output as inline review-comment suggestions on PRs (including fork PRs) without running fork-controlled ESLint plugins under a privileged token. - pr-autofix.yml: untrusted, runs lint:fix/format with permissions: {}, uploads diff artifact. paths-ignore on lockfiles/snapshots/dist to avoid reviewdog 406 on >3k-line diffs. - pr-autofix-publish.yml: trusted workflow_run consumer. Validates every metadata.json field with regex allowlists before exporting to GITHUB_OUTPUT (closes head_ref newline-injection vector). Concurrency keyed on PR number with fork fallback to head-repo+branch. Reviewdog pinned to v0.21.0. Sticky comment posts only when patch is non-empty (no noise on clean PRs); body carries a fenced gitnexus-autofix JSON block under a stable HTML marker for agent parsing. gh API calls go through a small retry helper for transient 5xx. Branch protection should enable merge queue + 'require branches up to date' to handle PR freshness; chinthakagodawita/autoupdate is dropped (unmaintained since 2023). * ci(autofix): close zizmor template-injection findings Move fork-controlled values (head.ref, head.repo.full_name, head.sha, pr.number, github.repository) into the step's env: block instead of interpolating them with `${{ }}` directly into the bash run body. The job has permissions:{} today so this is defence-in-depth, but a future scope grant on the untrusted half would otherwise turn a malicious branch name into shell injection. Add pr-autofix-publish.yml to the documented dangerous-triggers ignore list — workflow_run is required to post sticky comments on fork PRs and the file's structural defences (no fork checkout, allowlist on metadata.json, base_repo equality check) match the existing ci-report.yml exemption. * ci(autofix): close remaining review findings - Add an actionlint job to workflow-lint.yml. Catches YAML syntax, expression typing, shellcheck-inside-run, and deprecated runner labels on every .github/** PR — closes the gap that let pr-autofix's YAML literal-block bug reach review on this branch. - pr-autofix-publish.yml emits a `gitnexus/autofix` Check Run on the PR head SHA: conclusion `success` for clean, `neutral` (with distinct output titles) for suggestions-posted vs. skipped-too-large. Stable name lets agents read the outcome via `gh pr checks` without parsing the sticky comment. - Document the autofix signal contract in CONTRIBUTING.md — sticky marker, fenced gitnexus-autofix JSON schema, Check Run name. One source of truth so the marker / schema fields don't drift across the workflow files and consumers. * ci: fix actionlint/shellcheck findings on PR #1446 Closes the actionlint warnings the new lint job (workflow-lint.yml's actionlint runner) surfaced once it was wired into CI. Mostly shellcheck-style cleanups across three workflows. pr-autofix-publish.yml - SC2170: `[ "${{ steps.meta.outputs.changed_lines }}" -gt 3000 ]` interpolates a literal string into bash, breaking shellcheck's arithmetic-comparison parse. Move `changed_lines` through env: as `CHANGED_LINES` and reference as `$CHANGED_LINES` inside bash. ci-report.yml (Read PR metadata step) - SC2002 ×2: `cat file | tr` -> `tr < file`. - SC2129: three consecutive `>> "$GITHUB_OUTPUT"` redirects collapsed into one `{ ...; } >> "$GITHUB_OUTPUT"` group. ci-report.yml (Build report step) - SC2162 ×2: `read VAR1 VAR2` -> `read -r VAR1 VAR2` so backslashes in test-results.json output aren't mangled. - SC2034: drop unused `SUITES` aggregate. The per-framework suite counts (CLI_SU, WEB_SU) are now read into `_` placeholders since the report doesn't surface them anywhere. release-candidate.yml - SC2129 ×2: collapse consecutive `>> "$GITHUB_OUTPUT"` redirects in the rc-version computation step and the tag-push step into one grouped block each.	2026-05-09 13:35:04 +01:00
Gergő Magyar	ac9246cfd3	ci(docker): mirror signed images to Docker Hub alongside GHCR (#1029) ... * ci(docker): mirror signed images to Docker Hub alongside GHCR docker.yml now publishes to docker.io/abhigyanpatwari/gitnexus{,-web} in the same build step as the existing GHCR push, so both registries receive the same digest, the same Cosign keyless signature, and the same SBOM / build-provenance attestations. The Docker Hub login uses new repo secrets DOCKERHUB_USERNAME / DOCKERHUB_TOKEN (scoped PAT, not account password). Supply-chain guarantees carry over unchanged: the signing loop iterates metadata-action's full tag set, so Docker Hub tags get signed at the identical digest under the same docker.yml@refs/tags/v* identity. The ClusterImagePolicy is extended with docker.io / index.docker.io / bare- namespace globs so admission cannot be sidestepped by registry-prefix choice. README and .env.example document both registries; RC section in CONTRIBUTING.md notes the Docker Hub mirror tag. Closes #1027 * ci(docker): publish to akonlabs Docker Hub namespace; add PR dry-run CI - Hardcode `akonlabs` as the Docker Hub namespace in metadata-action and both attestation subject-names (Docker Hub org differs from GitHub org `abhigyanpatwari`, so `github.repository_owner` would produce the wrong ref) - Update docs (.env.example, README, CONTRIBUTING) and the Kubernetes ClusterImagePolicy globs to reference `akonlabs/gitnexus{,-web}` - Add `pull_request` trigger so the image build runs as CI on every PR (build only — no push, sign, or attestation) - Add `workflow_dispatch` with `dry_run: boolean` (default true) for manual build-only runs; all publish steps gated on `github.event_name != 'pull_request' && !inputs.dry_run`	2026-04-23 18:59:26 +01:00
Copilot	fa39a4b4a5	fix(docker): build and push Docker images for Release Candidates (#978)	2026-04-19 07:46:21 +01:00
Gergő Magyar	0a4b31b3c5	docs: optimize context files for LLM accuracy and token efficiency (#857) ... * docs: optimize context files for LLM accuracy and token efficiency Fix factual errors across all five root context files and optimize for LLM context window efficiency. Corrections: - Web UI: "runs entirely in WASM" -> thin client backed by HTTP API - Pre-commit hook: "typecheck + tests" -> formatting + typecheck only - MCP tools: 7 -> 16 (added api_impact, route_map, tool_map, shape_check, group_list/query/sync/contracts/status) - Default serve port: 3741 -> 4747 - E2E tests: "5 tests" -> 7 spec files - ESLint: "no config" -> eslint.config.mjs exists with TS/React rules - npm test: "vitest run test/unit" -> "vitest run" (full suite) - Removed nonexistent test:all script - ci-quality.yml: added missing format + lint job descriptions - Pipeline phase deps: added missing structure dep on mro/communities/processes - Ingestion entry: added missing run-analyze.ts intermediate orchestrator - Tools Quick Reference: added missing list_repos - Group tool examples: fixed param name (group -> name) - Removed stale vite-plugin-wasm gotcha - Added gitnexus-shared to repository layout tables New documentation: - ARCHITECTURE.md: language-agnostic graph feeding (provider pattern, unified capture tags, import resolution tiers, chunked parse, MRO) - ARCHITECTURE.md: full analysis flow (10 stages with progress %) - ARCHITECTURE.md: storage layout, LadybugDB schema, embeddings, search - ARCHITECTURE.md: DAG runner internals (Kahn's sort, dep isolation, error handling) Token optimization: - Removed filler prose, compressed descriptions into dense tables - Front-loaded key facts in every section - Eliminated redundancy between sections - AGENTS.md: 219 -> 201 lines. ARCHITECTURE.md: 192 -> 298 lines (more info in fewer tokens via tables and structure) * docs: optimize GUARDRAILS.md for LLM context efficiency Tighten prose without losing information: - Compressed intro, scope section, and Signs format labels - Shortened Sign headers (removed "Sign:" prefix) - Replaced verbose "Instruction/Reason" labels with "Do/Why" - Removed trailing whitespace and redundant emphasis	2026-04-16 08:43:11 +01:00
Gergő Magyar	109a3c6946	ci: standardize workflow concurrency and automate release-note labeling (#837) ... * ci: standardize workflow concurrency and automate release-note labeling Concurrency — prevent racing CI jobs - Every top-level workflow now declares an explicit concurrency block. - PR runs cancel-in-progress on supersede; main/push/workflow_call/publish runs queue instead of cancelling so every commit and every release is validated end-to-end. - ci.yml uses a literal `CI-` prefix (not `${{ github.workflow }}`) and a per-run nested group for workflow_call invocations, avoiding a potential deadlock with publish.yml and release-candidate.yml callers whose own concurrency groups could otherwise collide with the called workflow. - ci-report.yml falls back to `<head-repo>/<head-branch>` for fork PRs (stable across reruns) instead of the per-run-unique workflow_run.id which did not actually serialize anything. - ci-quality.yml enforces the convention: fails CI if any non-reusable workflow lacks a concurrency block or a reusable workflow declares one. Release-note automation - New pr-labeler.yml: amannn/action-semantic-pull-request enforces conventional-commit PR titles on pull_request (fork-safe, read-only); release-drafter/release-drafter with disable-releaser: true applies the matching label under pull_request_target (write-scoped). sync-labels in .github/release-drafter.yml removes managed autolabels that no longer match (e.g. when `!` or `BREAKING CHANGE:` is dropped from a PR). - .github/release.yml (unchanged) continues to map labels to categorized release-notes sections. - dependabot.yml added for the github-actions ecosystem so pinned SHAs auto-refresh on a weekly cadence. Docs - CONTRIBUTING.md documents the concurrency convention, the conventional-commit PR-title rules, and the reusable-workflow exception. Follow-up to verify before relying on the labeler in anger - gh api repos/amannn/action-semantic-pull-request/git/refs/tags/v5.5.3 - gh api repos/release-drafter/release-drafter/git/refs/tags/v6.0.0 - Confirm release-drafter reads its config from the base ref (not fork head) when invoked via pull_request_target. * ci: address PR review feedback on concurrency and labeler workflows Two blocking fixes - pr-labeler.yml: separate concurrency slots for pull_request and pull_request_target. Previously both triggers shared a single group with cancel-in-progress: true, so the privileged autolabel run could cancel the title-validation check mid-run and leave a required status in a permanent cancelled state. - pr-labeler.yml autolabel job: add contents: read. release-drafter's context.config() reads .github/release-drafter.yml from the default branch via the repo-contents API and 403s without the scope. Job-level permissions nullify all unlisted scopes so an explicit grant is needed. Two non-blocking improvements - Replace the hardcoded reusable-workflow allowlist in ci-quality.yml with dynamic on:-block parsing. New workflow_call-only workflows no longer produce false-positive convention failures. - Implement actual group-key validation. The check now also asserts that every concurrency.group expression references either ${{ github.workflow }} or the literal CI- prefix (the documented ci.yml exception). - Script extracted to .github/scripts/check-workflow-concurrency.py so it is runnable locally and independently testable.	2026-04-15 13:24:53 +01:00
Gergő Magyar	baf3f9e37d	feat(ci): add release-candidate publish pipeline (#825) ... * feat(ci): add release-candidate publish pipeline Auto-publishes gitnexus@rc on every merge to main. Version scheme is canonical semver X.Y.Z-rc.N where the base is the current npm 'latest' bumped by the 'bump' input (default patch) and N auto-increments by querying existing rc versions on the registry. First rc for a new base is rc.1; the counter resets naturally when the base advances after a stable release. - Reuses ci.yml via workflow_call so tests must pass before publish - SHA-pinned actions, per-job permission scoping, provenance enabled - Guard job dedupes duplicate dispatches against HEAD via v*-rc.* tags - Docs-only pushes skipped via paths-ignore - workflow_dispatch inputs: bump (patch/minor/major), force (override guard) - Publishes under the 'rc' dist-tag so 'latest' is never moved - Tags commits as v<rc-version> and creates GitHub prereleases * fix(ci): address release-candidate review feedback - Sort rc tags by creatordate (handles out-of-order pushes correctly) - Fail fast on npm registry errors; only fall back to package.json on E404 - Drop unused pull-requests: write permission on the reused CI job - Add secrets: inherit so any future CI secrets are available to sub-jobs - Remove unused reltag step output * fix(ci): address Copilot review comments - Correct concurrency comment (runs serialize on same ref, not overlap) - Apply E404-only fallback to 'npm view versions' query, matching the pattern used for the 'npm view version' query - README: clarify that docs-only merges don't trigger rc publish - CONTRIBUTING: drop 'from main' claim for publish.yml; the tag-push trigger does not enforce branch reachability * fix(ci): address adversarial review — idempotency, cycle continuity, tag integrity Codex adversarial review flagged three release-safety issues in the rc pipeline. Fixes: 1. Cycle continuity (H). Non-patch rc trains no longer collapse back to patch on the next push. 'bump' input accepts a new 'auto' value (default) that infers the active rc base from the registry: if any X.Y.Z-rc.* exists with X.Y.Z > latest, continue that base; otherwise patch-bump. Explicit patch/minor/major still forces a cycle reset and now also bypasses the dedup guard so an explicit dispatch on a tagged HEAD is honored. 2. Idempotency across post-publish failures (H). The guard marker ('rc/<HEAD_SHA>' lightweight tag) and the release tag ('v<RC>' annotated) are now pushed atomically *before* 'npm publish'. A publish failure leaves the marker in place and the guard refuses to re-publish. Added a defensive 'npm view <pkg>@<rc> version' check before publish to catch registry-level races. Recovery path documented in CONTRIBUTING.md. 3. Tag ↔ package integrity (M). 'v<RC>' now points at a detached release commit whose tree contains the rewritten package.json, so the tag's source archive matches the npm tarball exactly. 'main' stays pristine; the release commit is reachable only via the tag. * fix(ci): surface registry errors on defensive version check; drop actions: read - npm view <pkg>@<rc> version now distinguishes E404 (safe) from network failures (abort) via the same mktemp+grep pattern used for the other two npm view calls - Dropped actions: read on the ci workflow_call — no sub-workflow uses the Actions API	2026-04-14 17:32:47 +01:00
John R. Eakin	c68d7975e6	docs: agent development framework, GitHub templates, eval refactor (#479) ... * ci: E2E workflow, web typecheck job, pre-commit hook, test suite CI: - ci.yml consolidated to reference ci-tests.yml - ci-quality.yml: add typecheck-web job for gitnexus-web/ - ci-e2e.yml: E2E workflow with dorny/paths-filter (web changes only) - ci-report.yml: remove dead integration-reports references - CI gate allows skipped E2E status - .gitignore: playwright artifacts, eval test artifacts Pre-commit hook: - .githooks/pre-commit: typecheck + unit tests for both packages - Activated via git config core.hooksPath in prepare script Test infrastructure: - Vitest + React Testing Library: 58 unit tests (graph, server-connection, mermaid, settings, constants, utils, paths) - Playwright E2E: 5 tests + manual recording harness - vitest.config from vitest/config, engines.node >= 20 - Playwright artifacts retain-on-failure - wait-on in devDependencies - vitest/coverage-v8 aligned with vitest 4.x Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * chore: update gitnexus-web package-lock.json Reflects devDependency additions (vitest, playwright, wait-on, @testing-library, etc.) from package.json changes in this PR. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(e2e): add missing process-list-loaded testid, increase CI timeouts - Add data-testid="process-list-loaded" to ProcessesPanel (E2E tests were waiting for an element that didn't exist) - Increase server connect timeouts from 5s to 10s for slower CI Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(ci): run gitnexus-web unit tests in CI, remove unused variable - Add gitnexus-web npm ci + vitest run to ci-tests.yml so web unit tests are gated by the CI status check (were only running locally) - Remove unused IS_PLAYWRIGHT_AUTOMATION variable from E2E spec Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(e2e): add process-row testid, wait for networkidle on page load - Add data-testid="process-row" to ProcessItem component (E2E tests referenced it but it didn't exist in the source) - Use waitUntil: 'networkidle' on page.goto to ensure Vite dev server is fully ready before interacting (fixes first-test timeout in CI) Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(e2e): add process-view-button and process-highlight-button testids E2E tests referenced these data-testid attributes but they didn't exist in ProcessItem. All 6 E2E testids now have matching source elements: status-ready, process-list-loaded, process-row, process-view-button, process-highlight-button, server-url-input. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(e2e): remove networkidle — Vite HMR WebSocket prevents it from resolving networkidle waits for zero network activity for 500ms, but Vite's HMR WebSocket stays open permanently, causing page.goto to timeout at 60s on all tests after the first. The explicit toBeVisible waits on UI elements are sufficient and deterministic. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(e2e): wait for Server button visibility, add CI retry, all 5 tests pass locally Root cause: test 1 clicked the Server button before React hydrated, so the tab content never rendered and the input wasn't found. Fixes: - Wait for Server button toBeVisible before clicking - Increase input wait to 15s - Remove networkidle (Vite HMR WebSocket prevents it from resolving) - Add retries: 1 in CI for transient cold-start flakiness Verified locally: all 5 E2E tests pass, 198 unit tests pass, typecheck clean. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(ci): tolerate LadybugDB native crash during analyze step gitnexus analyze can crash with "double free or corruption" (known issue #273) during the LadybugDB native addon shutdown. The index is usually written successfully before the crash. The workflow now: 1. Allows analyze to exit non-zero with a warning 2. Verifies .gitnexus index was actually created 3. Only fails if no index exists (real failure) All tests verified locally: 198 unit, 5 E2E pass, typecheck clean. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(ci): fix shell quoting in analyze step, simplify to || true The previous echo string had special characters that broke bash quoting in GitHub Actions. Simplified to: analyze || true, then check if .gitnexus exists. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * docs: add agent development framework, GitHub templates, eval refactor Agent framework (layered docs for AI-assisted contributions): - AGENTS.md: canonical instructions, impact analysis, MCP tools - CLAUDE.md: Claude Code-specific deltas and hooks - GUARDRAILS.md: safety boundaries, non-negotiables, escalation - ARCHITECTURE.md: monorepo layout, data flow map - TESTING.md: test structure, commands, categories - RUNBOOK.md: copy-paste operations for dev/CI/MCP - llms.txt: minimal LLM context pointer Editor integration: - .cursor/index.mdc + rules/100-monorepo.mdc GitHub templates: - PR template with areas-touched checkboxes - Bug report + feature request issue forms Eval harness: - Refactored mcp_bridge, tool_registry, constants - Error sanitization utilities - Property-based tests via Hypothesis Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * fix(eval): use format_exception instead of format_exc in sanitize_exception format_exc() returns the currently handled exception traceback, which may be unrelated if called outside an active except block. Using format_exception(type(exc), exc, exc.__traceback__) reliably captures the passed exception's traceback. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * docs: update CONTRIBUTING.md and TESTING.md for current CI/hook setup - CONTRIBUTING.md: add gitnexus-web typecheck command, pre-commit hook checklist item - TESTING.md: add gitnexus-web typecheck command, pre-commit hook section (husky), update CI integration to list actual workflow files (ci-quality, ci-tests, ci-e2e) Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * docs: update testing docs to reflect CI/E2E changes from PR #486 - AGENTS.md: update test counts (CLI ~2000 unit, ~1850 integration), add gitnexus-web testing section (198 unit, 5 E2E with commands) - RUNBOOK.md: fix Node requirement to >=20, fix E2E local repro command - TESTING.md: E2E uses data-testid selectors + real servers, not mocks - .cursor/rules/100-monorepo.mdc: add web test/E2E commands Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * docs: address context engineering review — deduplicate tokens, expand Cursor rules - Remove ~100-line gitnexus:start block from CLAUDE.md (was duplicated from AGENTS.md) - Fix gitnexus:start block inlined inside AGENTS.md Reference Docs bullet (doubled) - Replace CLAUDE.md scope table with pointer to AGENTS.md (single source of truth) - Expand .cursor/index.mdc with 5 non-negotiable safety rules for always-on context - Add .cursor/rules/200-eval.mdc with Python/eval commands (glob-scoped to eval/**) - Improve llms.txt with priority annotations and descriptions - Bump version headers to 1.2.0, last-reviewed to 2026-03-24 Saves ~1,400 tokens/session with zero information loss. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com> Co-authored-by: Gergő Magyar <gergomagyar@icloud.com>	2026-03-25 06:48:41 +00:00