6fa48454283776c008069ca76c6d580efd7c00a7
23
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
6fa4845428 |
build(deps-dev): Bump @types/node in the npm-minor-patch group (#5)
Bumps the npm-minor-patch group with 1 update: [@types/node](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/HEAD/types/node). Updates `@types/node` from 26.1.1 to 26.1.2 - [Release notes](https://github.com/DefinitelyTyped/DefinitelyTyped/releases) - [Commits](https://github.com/DefinitelyTyped/DefinitelyTyped/commits/HEAD/types/node) --- updated-dependencies: - dependency-name: "@types/node" dependency-version: 26.1.2 dependency-type: direct:development update-type: version-update:semver-patch dependency-group: npm-minor-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> |
||
|
|
5d1e6d21b3 |
build(deps): Bump schemars in the cargo-minor-patch group (#6)
Bumps the cargo-minor-patch group with 1 update: [schemars](https://github.com/GREsau/schemars). Updates `schemars` from 1.2.1 to 1.2.2 - [Release notes](https://github.com/GREsau/schemars/releases) - [Changelog](https://github.com/GREsau/schemars/blob/master/CHANGELOG.md) - [Commits](https://github.com/GREsau/schemars/compare/v1.2.1...v1.2.2) --- updated-dependencies: - dependency-name: schemars dependency-version: 1.2.2 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: cargo-minor-patch ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> |
||
|
|
1e3e179205 |
docs: record the version holds and where to pick up
ARCHITECTURE section 10 now lists all three deliberate version holds together — rusqlite 0.37, TypeScript 6, and ESLint 10 without eslint-plugin-react — each with the compile or lint failure that forces it. Dependabot will keep proposing every one of them, and a reviewer looking at those PRs needs the reason in the version manifest rather than buried in a commit message. ROADMAP Phase 1 gains a "where to pick up" section: CI is green on the published commit, and the next four things are closing the two Dependabot PRs that would break the build, watching ci-integration.yml actually run for the first time rather than assuming it passes, the owner-only repo settings, and the SP-5 tangle environment that is still the outstanding M1 exit criterion. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
566ee27da8 |
fix(ci): scope the cargo audit gate to vulnerabilities
With the toolchain fix in place the audit actually ran, and reported zero vulnerabilities. It failed on informational advisories instead: seventeen "unmaintained" or "unsound" notices, eleven of which are Tauri's archived GTK3 bindings -- a Linux-only dependency tree that a Windows-only build never compiles. .cargo/audit.toml ignores those specific advisory ids with the reason next to each, rather than switching off informational warnings as a class. The distinction matters: a new advisory still fails CI and has to be looked at, instead of being silently absorbed by a blanket rule. The vulnerability gate SECURITY section 7 promises is untouched. Each block carries its own review trigger, because a stale ignore is how a real advisory eventually gets waved through: the GTK3 entries come out when Tauri moves to GTK4, and adding macOS/Linux builds (P2-1) is the point at which that list must be re-examined rather than extended. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
c3fc8e4f5a |
fix(ci): grant callees the permissions they declare, unpin the audit build
Three failures from the first push, all of them CI configuration rather than code. CodeQL and CI/Node both hit startup_failure with no logs. A caller cannot grant a called workflow less than its jobs declare, and the run is rejected before anything starts, so there is nothing to read. reusable-codeql.yml's analyze job asks for `packages: read` to fetch CodeQL packs, and reusable-web-react.yml's deploy job asks for `pages: write` and `id-token: write`. The deploy job is skipped here (deploy-pages: false), but permissions are validated at startup regardless of `if:`. This is the trap RELEASE-CI.md section 1 already records -- "callers without a permissions block default everything to none" -- met from the other direction: having a block is not enough if it grants less than the callee asked for. Both comments now say so at the point of use. cargo audit failed to compile rather than finding an advisory. rustsec/audit-check builds cargo-audit from source, and rust-toolchain.toml pinned that build to PipDock's 1.94.1; cargo-audit's own dependency tree needs 1.96. The job now builds it with stable, which is correct in principle too: the pin exists to make PipDock reproducible, not its tooling, and cargo-audit only reads Cargo.lock. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
779c1e8560 |
feat: complete the M1 command surface and close the milestone
Adds the last commands: env use, pip-upgrade, snapshot rollback, schema, self report-bug, and engine <pip|uv>. Every P0 CLI command now works except health, which belongs to M3 with the tools venv. Rollback follows DATA-FLOW section 8 including the part that is easy to skip: it snapshots the current state before replacing it, because a rollback is itself reversible. Verified end to end — installing httpx 0.23.0 and rolling back left the environment with pip alone, and the diff afterwards reported "matches snapshot". Two things the compiler and the smoke test caught: - `pipdock engine pip` was never handled. Only the no-argument form was wired, so the documented setter silently did not exist; the non-exhaustive match surfaced it once the catch-all arm was removed. That catch-all had been hiding it. - engine_for ignored any stored preference and always returned pip, so configuring an engine would have had no effect. It now reads the store, and setting an unavailable engine is refused rather than saved — storing a preference that cannot be honoured just moves the failure to the next command. schema generates from the Rust types via schemars rather than being hand-written, because a hand-written schema drifts the moment a field is added and then lies to every script pinning against it. A test asserts every advertised type actually resolves. ci-integration.yml implements TESTING L2: real pip and uv against throwaway venvs on Windows, across the 3.10 floor and 3.14 ceiling, with an end-to-end pass that checks the claims the docs make — the SP-1 conflict is still reported and attributed, update/rollback round-trips leave the environment matching the snapshot, the guard still refuses to break requests, and the exit codes still match CLI-SPEC section 5. A weekly job re-captures fixtures against the newest engines so an output change surfaces as a failed job rather than as PD-ENG-003 on a user's machine. The ROADMAP entry is honest about what is not done: L2 has never actually run, the L4 golden-output tests are not written, and the SP-5 exit criterion named a real numpy/scipy/pandas environment that the httpx/httpcore construction stood in for. 173 tests, clippy -D warnings clean, npm audit clean, all workflows parse. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
d39bad5c78 |
feat(core): PEP 691 index, tiered search ranking, metadata cache
`search`, `info` and `index refresh` work against the real index: 858,547 projects fetched and ingested in 4.1s against a 60s budget. Ranking is tiered rather than score-ordered, which is what SP-3 said was required: raw nucleo put requests-ntlm above requests and numpy-utils above numpy, the two most obvious queries in the product. A fuzzy score is a good tie-breaker and a bad primary key -- it rewards density, so a longer name containing the query densely beats the name the user typed. Ordering is now match kind, then score, then shorter name, then alphabetical so results never reorder between identical keystrokes. Verified against the live index: `requests` and `numpy` rank first. Measuring the shipping path rather than a spike loop changed the conclusion. SP-3 timed a bare nucleo loop at 42.1ms, ~16% under budget. The real implementation measured 90.5ms -- nearly twice over: tiered ranking, full sort 90.5 ms + rank by selection instead of sorting 52.5 ms + subsequence prefilter, min fuzzy length 16.5 ms The first number is the lesson: a four-level comparator over ~800k candidates costs more than the fuzzy matching it was ordering. Only `limit` results are ever shown, so ranking is a selection, not a sort. Below three characters there is no fuzzy pass at all. That started as a performance fix and is also the better answer: fuzzy-matching one character across 858k names returned noise, and someone two characters in wants names that *start* that way. The subsequence prefilter is nucleo's own necessary condition, so it skips scoring for names that cannot match without dropping any that could. At 16.5ms there is real headroom for the low-end machine SP-3 asked about and could not test. The sp3_search example now measures NameIndex::search itself rather than a private copy -- a benchmark that drifts from the implementation reports numbers nobody can act on. Metadata is cached for 24h per ARCHITECTURE section 5, and an offline fetch falls back to a stale entry with a badge rather than an error, because the data is still useful and search itself stays local. The HTTP client verifies certificates and refuses redirects off pypi.org or files.pythonhosted.org; a TLS failure gets PD-NET-002 and its own guidance, never a suggestion to disable verification. 172 tests, clippy -D warnings clean. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
5f2504d6d9 |
feat: update and install, and the held-back synthesis they need
The preview PipDock exists to show now works end to end. Against a real
venv seeded with httpx 0.23.0:
$ pipdock update httpcore --dry-run
Needs decision — held back:
httpcore 0.15.0 (latest 1.0.9)
httpx 0.23.0 requires httpcore <0.16.0,>=0.15.0
That is PRD G2's promise verbatim, and no engine produces it. SP-1
established that neither pip nor uv has the concept of a held-back
package at all -- unconstrained they upgrade httpcore to 1.0.9 and break
httpx at exit 0. All three parts of the sentence are assembled by
PipDock: the resolved version from the plan (or from its absence), the
latest from the index, and the culprit from the reverse-dependency graph.
Constraints that permit the target are never named, and when nothing
explains a hold the row says so rather than inventing a cause.
Two bugs were found by running it rather than by testing it, and both
were invisible failures:
- resolve() passed only the guard set to the engine, never the packages
being upgraded. pip was asked to upgrade nothing, reported no changes,
and every selected package looked held back with no discoverable cause
-- the feature appeared to work while telling users nothing.
- argv_dry_run omitted -U, so pip treated each installed package as
already satisfying its requirement. The unit test asserting it "matches
the documented command" had encoded the omission instead of the
document, which is exactly how this passed CI. Both the flag and the
test now match DATA-FLOW section 7.
With both fixed the behaviour is coherent: upgrading httpcore alone
reports it held back, while `update --all` resolves the whole tangle to
latest, because moving httpx to 0.28.1 releases the constraint. Verified
by applying it -- snapshot written first, seven packages upgraded, `pip
check` clean afterwards, and the snapshot diff showing precisely what a
rollback would restore.
--no-snapshot is now supported rather than refused, but not by weakening
the invariant. execute() takes a SnapshotProof, which is either a real
Snapshot or WaivedForDisposableEnvironment. Option<&Snapshot> would have
made forgetting a snapshot indistinguishable from deliberately waiving
one; a named variant makes every waiver greppable and states what the
caller is asserting.
Conflict decisions follow CLI-SPEC section 4: interactive per-package
prompts on a TTY, and off one the defaults never force -- held-back
resolves to compatible, impossible to skip. Forcing does more than ask
for the newest: it also releases the blocker from the guard set, which is
the package that ends up broken, and is why the warning has to name it.
154 tests, clippy -D warnings clean.
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
|
||
|
|
1343924849 |
feat(core): pins, the pin store, and the uninstall guard
The guard is the feature DATA-FLOW section 5 calls a core value-add, because bare `pip uninstall` performs no dependency check at all. Verified against a real venv: removing urllib3 while requests is installed now refuses, names what breaks, and suggests the expanded set that would be safe. Three decisions shape whether it is trustworthy rather than noisy: - Extra-gated requirements do not trip it. aiohttp declares Brotli only under extra == "speedups", and claiming that removing Brotli breaks aiohttp would be false. A guard users learn to dismiss protects nobody. - It is evaluated once against the whole set, so removing x and y together is clear even though removing x alone is not. Asking per package would raise a warning nobody can act on. - "Remove dependents too" is the transitive closure. Stopping after one level would hand the user a set that still breaks something -- and is guaranteed to fail its own re-guard. The closure terminates on cycles because packages enter the frontier once. Without --force a guard trip aborts and executes nothing, exiting 1 so the CI idiom in CLI-SPEC section 7 works with a bare `||`. Pins land with the store they need. filter_upgrades is the enforcement point for DATA-FLOW section 9.5, and it returns what it excluded rather than dropping it silently -- UI-SPEC section 4 wants "3 pinned excluded", because a selection that quietly ignores part of what you selected is worse than one that refuses. The only override is a package unpinned in the same session, which is the escape hatch the invariant itself names. Two mode distinctions that matter: Exclude means "do not sweep this up" and must not freeze the resolver's hand when the package moves as someone else's dependency, so only Hold pins contribute exact requirements. And pins are keyed by env_hash, which is case-folded upstream, so a shim and the interpreter it points at share one pin list instead of diverging invisibly. Removals go through the same snapshot gate as installs -- verified: the snapshot is written before anything is touched, and the diff afterwards correctly reports both removed packages. 140 tests, clippy -D warnings clean. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
da1a707e1b |
feat(core): snapshots and two-phase execution
Two of the DATA-FLOW section 9 invariants stop being rules that review has to catch and become facts the compiler enforces. AcceptedPlan has no constructor other than accepting a report, and execute() takes one along with a Snapshot. A caller that skipped the preview or skipped the snapshot cannot produce the arguments, so "no mutating call without an accepted plan and a successful snapshot" is now structural rather than aspirational. AcceptedPlan also carries what section 9.3 needs: when it was confirmed and a fingerprint of the installed set at that moment. Both a stale preview and one made before the environment drifted are refused with PD-RES-002, because executing a plan the user did not actually see is the failure "preview before touch" exists to prevent. The fingerprint is order-independent -- engines do not promise a stable listing order, and treating a reorder as drift would refuse valid plans at random. Execution is the two phases ARCHITECTURE section 8 specifies. Phase A is one invocation for the whole set; on failure Phase B re-runs per package and keeps going past failures. The test that matters asserts the owner's requirement directly: fifteen packages with two bad ones applies thirteen, visits all fifteen in Phase B, and every failed row carries a catalog code. Aborting would cost the user thirteen good packages to punish two bad ones. An engine that cannot even be spawned is recorded as that one package's outcome rather than discarding the ones that already succeeded. Snapshots keep two things honest. The sidecar records which engine wrote the freeze, because pip freezes with --all and uv does not -- without it a cross-engine diff reads as "pip was uninstalled". And entries that cannot be restored from an index (editable installs, direct URLs, VCS requirements) are skipped from the pin set but reported separately, so a rollback never claims success while leaving the environment different from the snapshot. The rollback planner touches only what differs; reinstalling the untouched 198 packages of a 200-package environment would take minutes and risk failures on packages that were fine. `snapshot create|list|diff` are wired and verified against a real venv, including a diff that correctly detects a package installed after the snapshot was taken. 124 tests, clippy -D warnings clean. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
7366c56366 |
feat: first working vertical slice — env discovery, adapters, CLI
`pipdock env list`, `list [--outdated]`, `doctor` and `engine` now run against real environments. Exit codes verified against CLI-SPEC section 5: 0 on success, 3 for a missing environment, 10 for a command that is not wired yet. Discovery implements the SP-6 findings rather than the naive version. Sources are merged by canonical identity, so the Chocolatey shim and the direct install collapse into one entry instead of appearing twice, and `<download available>` rows from `uv python list` are dropped rather than offering to manage a Python that is not on the machine. env_hash case-folds, so one environment cannot split its pins and snapshots in two. plan_requirements is the SP-1 finding turned into code, and it is the piece the product's core promise rests on: every resolve restates the installed set as pinned requirements, minus whatever the user is moving. Without it both engines upgrade straight past an installed package's constraint and exit 0, so the preview would show a plan that breaks the environment. `list` reads from probe.py rather than `pip list`, because the probe carries requires_dist and the engine listing does not, and prints the user-site note when the listing is genuinely partial rather than as a standing disclaimer. I caused a real problem during this work and fixed it. The PEP 668 capture scenario planted an EXTERNALLY-MANAGED marker using the venv's sysconfig stdlib path -- which for a venv resolves to the BASE interpreter, not the venv. It landed in the user's actual Python 3.12 install and would have blocked pip there permanently. It surfaced because `env list` showed a MANAGED chip on an environment that should not have had one. The marker is removed, both interpreters verified clean, pip on 3.12 confirmed working, and the scenario that planted it is gone from the harness. The lesson is in capture.py: a fixture script must not write outside its temp directory, and sysconfig paths inside a venv are not venv-local. 97 core tests, clippy -D warnings clean. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
900c6ed35c |
feat(core): reverse-dependency graph and plan parsers
The graph is what makes the preview's "held back because X requires Y" sentence possible at all. SP-1 established that no engine reports held-back items -- pip's report is simply empty and uv says "Would make no changes" -- so all three parts of that sentence are assembled by PipDock. ARCHITECTURE section 3's rule that ambiguity must show the constraint without a culprit is enforced by construction: blockers_for returns only dependents whose declared constraint actually excludes the target, so a package that permits the version is never named. An empty result stays empty rather than degrading into a guess, because a confidently wrong culprit sends the user to change the wrong package. Two details that decide whether the guard is trustworthy: - Extra-gated requirements are excluded. aiohttp declares Brotli only under extra == "speedups", and warning that removing Brotli breaks aiohttp would be false. A guard users learn to dismiss protects nobody. - The guard is evaluated once against the whole removal set, per DATA-FLOW section 5. Removing x and y together is fine when only y depends on x, and asking per package raises a warning nobody can act on. The parsers normalise two outputs that could hardly be less alike -- JSON on stdout versus wrapped decorated text on stderr, is_yanked field versus warning line, report-with-no-previous-version versus explicit "- name==old" lines -- into the one ResolutionReport the Engine trait promises. Replaying the captured fixtures immediately found a defect worth having: the SP-2 encoding crash does not leave stdout empty, it leaves a *truncated* report. Parsing that would have produced a plausible-looking plan quietly missing packages, which for a tool whose promise is "preview before touch" is the worst possible failure. The crash signature is now checked before anything is parsed. The fixture replay asserts meaning rather than exact structures, so it survives cosmetic engine changes instead of training us to re-bless snapshots without reading them. It also pins SP-1's findings as regression gates: both engines still break httpx when unconstrained, both still return an empty plan when the installed set is restated, and uv still writes everything to stderr. If any of those stop being true, the planning strategy can be simplified and the test says so. 92 tests, clippy -D warnings clean. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
7a30e635f7 |
feat(core): subprocess layer and error classifiers
Two pieces of M1, both of which turn a documented rule into something the code cannot forget. exec.rs is the single chokepoint for every external command. Command takes a program and a Vec<String> and has no path that accepts a command line, so the "argv arrays, never a shell" rule of SECURITY section 2 is structural rather than a convention. Command::python() applies the SP-2 UTF-8 mitigation unconditionally, so no future call site can reintroduce the pip --report crash by forgetting it. canonical_interpreter() case- folds on Windows, which is the SP-6 finding about pins and snapshots splitting in two. The classifiers are driven by the captured corpus rather than by strings someone typed into a test, and writing that gate immediately paid for itself by failing on four real defects: - uv reports an unknown package *through* its resolver, so not-found was classified as a version conflict. That would send users hunting for a constraint problem that does not exist. - uv hard-wraps its diagnostics, so "was not found in the package\n registry" never matched as a literal. The classifier now collapses whitespace before matching, which makes every multi-word pattern wrap-proof. - pip prefixes unrelated failures with "Ignored the following yanked versions", which hijacked the Requires-Python fixture as a yank. The yank rules are removed entirely: a yank is not a failure at all, since both engines exit 0 and install the release. It is detected structurally by the plan parsers and shown as a preview warning. - Five catalog codes had no evidence of any kind. On coverage: two codes moved to the internally-raised table because that is where they genuinely belong, not to dodge the gate. PD-PKG-001 is raised by compat before an engine runs, and PD-ENV-002 is caught from probe.py's externally_managed field at step zero. The PEP 668 scenario is removed from the harness with its reasoning: the marker only applies outside a venv, deleting pyvenv.cfg to fake that just breaks the venv launcher, and planting it in a real system Python is not something a fixture script should do to a developer's machine. Two conditions that WERE reproducible are now real captures rather than guesses: PD-NET-001 via an unreachable index, and the uv phrasing for it, which needed three patterns pip does not use. The remaining eight are synthetic, each flagged, justified, and carrying what would replace it; a test enforces that labelling so they can never be mistaken for evidence of real engine behaviour. 58 tests, clippy -D warnings clean. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
4ab948ac7b |
feat: implement the two owner decisions from spike week
Requires-Python is now enforced by PipDock, not by the engine. SP-2 found the engines disagree: scipy 1.7.3 declares >=3.7,<3.11, and on Python 3.12 pip refuses it while uv plans to install it. G5 promises one behaviour across heads, so the preview must not change shape because the user flipped the engine radio. crates/pipdock-core/src/compat.rs screens every candidate against the environment's version before any engine command runs; rejects surface as PD-PKG-001 with the required range shown against the found version. This does not weaken "explain, don't reimplement" — resolution stays entirely the engine's. compat.rs only filters candidates the engine should never have been offered, using the slice of PEP 440 that actually appears in Requires-Python: comparison, wildcard and compatible-release operators. Specifiers it cannot parse count as compatible, because PipDock failing to read metadata must never be the reason an installable package is refused. Nine tests, including the exact scipy case the spike captured and the boundary cases where an off-by-one would reject a supported Python. probe.py keeps -I, and the cost is disclosed rather than hidden. Isolated mode is what stops a poisoned environment injecting code into the probe, so it stays; dropping to -E was rejected because a package in user site is part of the untrusted surface the isolation exists to exclude, and probing twice was rejected as a second interpreter start per scan for a non-primary case. Instead probe.py now reports hidden_user_site — the user-site path when it exists, sits off sys.path and is non-empty, else null. Verified: the system Python reports the path (352 dists), a venv reports null. The Installed screen shows a note naming the path only when it is non-null, so users of the affected case are told exactly what is missing while everyone else sees nothing. ERROR-CATALOG PD-PKG-001 changes from a stderr classification to a PipDock-raised code, because engine stderr cannot support it: pip reports it as plain "No matching distribution found", indistinguishable from PD-PKG-002, and uv does not enforce it at all. Docs updated: ARCHITECTURE 3 and 4, DATA-FLOW 2, SECURITY 2, UI-SPEC 4, ERROR-CATALOG 2, ROADMAP, CLAUDE.md, spikes/README.md. EN and VI strings added for both notes. Two non-blocking questions remain in spikes/README.md: search-ranking scope for M1, and how to obtain the five error fixtures this machine cannot produce. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
ca7bd9e718 |
fix(lint): stop ESLint walking into the spike venvs
The SP-4 work left Python venvs under spikes/, and their site-packages ship stray .js files (urllib3's emscripten worker). ESLint's flat config does not read .gitignore, so it linted them and the type-aware rules crashed on files outside the tsconfig program. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
7f152200ac |
fix: preserve engine fixture bytes exactly
Git normalised CRLF to LF when the fixtures were committed: the blob for uv/yanked/stderr.txt held 0 carriage returns where the real engine output has 6. pip and uv emit CRLF on Windows, so the adapter parsers would have been tested against line endings that never occur in production — a parser mishandling a trailing \r would pass CI and fail on every real Windows machine. TESTING section 1 makes adapter parsing the thing that must never regress, so .gitattributes marks the fixture tree -text -diff and the blobs are re-added with their true bytes. The override is listed last because later gitattributes rules win; placed before `* text=auto` it has no effect. Verified with git check-attr and by comparing carriage returns in the staged blob against the working file. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
ab4d55ea0c |
feat(spikes): run Phase 0 spike week, SP-1 through SP-6
18 fixtures (9 scenarios x 2 engines) plus a reproducible capture harness. Findings written up in spikes/README.md and summarised in the ROADMAP Phase 0 table. Verdict: GO for shipping both engines, but for a different reason than the roadmap anticipated. SP-1 asked whether uv's plan output is too lossy to ship uv in v1.0. The question turned out to be the wrong shape. Neither engine holds packages back on `install -U <pkg>` — seeded with httpx 0.23.0, which requires httpcore<0.16, both pip and uv plan httpcore 1.0.9 and exit 0, silently breaking it. Restating the installed set as explicit requirements is what produces the correct held-back plan. That makes it a hard requirement on both adapters, not an optimisation: without it PipDock would preview a plan that breaks the environment. uv also writes its entire plan to stderr, and its conflict attribution is markedly better than pip's — uv names the exact blocking constraint where pip says only that versions conflict. SP-2 found a blocker. `pip install --dry-run --report -` crashes with UnicodeEncodeError on Windows under cp1252, because pip routes the report JSON through vendored rich and the console codec. Confirmed on pip 25.0.1 and 26.1.2, so it is current, not legacy. It is data-dependent — an all-ASCII report succeeds — which means it would pass local testing and fail on users' machines. PYTHONIOENCODING=utf-8 plus PYTHONUTF8=1 fixes it, and the crash is kept as a fixture so a regression is recognisable. Also: yanked releases exit 0 in both engines, so PD-PKG-003 belongs in the preview as a warning rather than in the failure path the catalog implies; and the two engines disagree on Requires-Python enforcement. SP-3 passes: 858k projects, 2.95s cold refresh against a 60s budget, 42.1ms worst keystroke against 50ms. But only in memory — scanning SQLite per keystroke costs 218ms, four times over. Two cautions recorded: 16% headroom on fast hardware is thin for the low-end VM the spike asked about, and raw nucleo ranking puts requests-ntlm above requests, so the Search screen needs an exact/prefix boost to be usable. SP-4 confirms SECURITY section 6 as written: --path cannot combine with --no-deps, so freeze-file mode is the only option for a foreign env. SP-5 is answered by SP-1 — no engine reports held-back items at all, so resolved version, latest version and blocker must all be derived by PipDock, for pip as much as for uv. SP-6 avoided two identity bugs. `uv python list` returns downloadable entries and shims that duplicate real interpreters, and the same interpreter reports different path casing depending on how it was launched, so env_hash must lowercase on Windows or a single environment silently splits its pins and snapshot history in two. Microsoft Store Python is not installed here and remains unverified. Four decisions are queued for the owner at the end of spikes/README.md; two of them change adapter behaviour and should land before M1. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
8f6b7ed24b |
feat: scaffold the Tauri shell, React UI and CI
Completes the Phase 0 scaffold. The app builds, links and renders; no screens yet. Frontend (ARCHITECTURE section 9, UI-SPEC section 2): - React 19 + Vite 8 + Tailwind 4 with the UI-SPEC dark terminal-tech tokens, plus a contrast test asserting WCAG AA over every text/surface pair, which UI-SPEC section 8 requires be verified. - EN and VI catalogs with a test that vi has every en key and no orphans, standing in for the CI parity script I18N section 1 asks for. - A local eslint rule enforcing the no-hardcoded-JSX-strings policy. eslint-plugin-react was the obvious choice but caps at ESLint 9, which drags in six high-severity advisories that would fail npm audit in CI; a local rule also implements the documented allowlist (product name, package names, versions, catalog codes, glyphs) precisely, which react/jsx-no-literals cannot express. Verified it fires on real copy and stays quiet on all five allowed shapes. - no-restricted-imports keeps invoke() out of components, so the "no component calls invoke directly" rule is enforced, not just stated. Tauri (ARCHITECTURE section 7): commands and events only, identifier com.skullmute.pipdock, NSIS and MSI targets, minimal capability set, placeholder icon pending the Phase 3 branding pass. CI (docs/RELEASE-CI.md section 1 as corrected): - ci-rust.yml and release.yml are project-local, on Windows runners, because no reusable Rust or Tauri workflow exists in the ops repo. Windows matters here: env discovery reads the PEP 514 registry and the py launcher, so a Linux run would skip the code most likely to break. - ci-node.yml calls the ops web-react reusable and adds the npm audit job that reusable lacks. - codeql.yml is JS/TS only; CodeQL has no Rust analyzer. - Discord notifiers replace the six-platform notify.yml that never existed. Every caller carries an explicit permissions block. - Action versions checked against the registry rather than assumed: checkout v7, cache v6, gh-release v3, setup-node v6. Two toolchain holds, both forced and both recorded: - TypeScript 6.0.3, not 7: typescript-eslint peers on <6.1.0. - ESLint 10 with eslint-plugin-react dropped, as above. Verified: cargo fmt/clippy -D warnings/28 tests green, tsc clean, 18 vitest tests green, eslint clean, npm audit reports 0 vulnerabilities, vite build and both binaries link. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
c4fe1c34e6 |
feat(core): scaffold the Cargo workspace, core crate and CLI surface
Phase 0 scaffold per ARCHITECTURE section 2. Everything compiles; nothing resolves or mutates yet. Implemented rather than stubbed, because the spikes need them and they are the parts the invariants rest on: - errors/catalog.rs: all 30 launch codes with their wire forms, plus tests that the wire codes are unique and match the PD-<AREA>-<NNN> grammar. Code::ALL drives the future "no code without fixture" gate. - model.rs: PkgName::parse does PEP 508 validation and PEP 503 normalization. This is the only way a name reaches an argv array, which makes SECURITY section 2 structural rather than aspirational; the test table rejects flags, separators and quoting attempts. - probe.py: stdlib-only, Python 3.10 floor, per ARCHITECTURE section 4. - The pip/uv argv builders, with tests asserting one token per argument. - ExecutionSummary::tally, so the "13 successful, 2 failed" headline is derived from the rows rather than accumulated alongside them. Stubbed with todo!() and a pointer to the milestone that fills them: the Engine trait impls, discovery, index, graph, snapshot, pins, health. UvEngine::parse_dry_run stays unimplemented on purpose — SP-1 must pin uv's text plan format before anything parses it. Two findings recorded in spikes/README.md: - probe.py under -I hides user-site packages: 352 dists vs 376 without it and 375 from pip list, on a non-venv system Python. Venvs are unaffected. The fix trades a documented security control against list accuracy, so it is left as an open SP-6 decision rather than settled here. - Python 3.14 deprecates subscripting absent metadata headers, which wrote DeprecationWarning to stderr on most distributions. probe.py now uses .get(); the probe must stay stderr-clean because noise reads as PD-ENV-003. rusqlite is held at 0.37: 0.40 pulls libsqlite3-sys 0.38.1, whose build script needs the unstable cfg_select! and will not build on stable 1.94.1. Recorded in the ARCHITECTURE version manifest. cargo fmt, clippy -D warnings and 23 tests are green. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
43c96c134d |
docs: correct CI docs against the actual ops repo
The CI docs were written against an assumed poli0981/.github suite. Audited the real one on 2026-07-27; four claims did not hold: - no reusable Rust workflow and no reusable Tauri workflow exist, and only reusable-desktop-csharp.yml uses a Windows runner, so ci-rust.yml and release.yml must be project-local - notifications are Discord-only via discord_notify.py; there is no notify.py and no Telegram/Bluesky/Mastodon/X/Facebook fan-out - dependency updates are Dependabot, not Renovate (no Renovate config exists anywhere in the ops repo) - setup-secrets.sh does not exist; use gh secret set Also records that reusable-codeql.yml has no Rust support (CodeQL has no Rust analyzer) and that reusable-web-react.yml has no working-directory input, which is why package.json sits at the repo root. Intent is preserved throughout: grouped weekly bumps, immediate security PRs and isolated tools-requirements.txt bumps are now expressed in Dependabot terms rather than dropped. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
099bce0c38 |
docs: add CLAUDE.md with doc reading order and hard invariants
Records the five design invariants that must never be violated (accepted plan + snapshot before any mutation, argv-only subprocess, never reimplement resolution, codes-not-strings from Rust, no implicit --break-system-packages), the naming conventions, and the corrected CI picture. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
5e8d78bb27 |
docs: add design documentation baseline
Commits the full v0.1 design suite written during the design phase: PRD, architecture, data flow, UI/CLI specs, code-health spec, error catalog, security, testing, release/CI and i18n docs, plus the roadmap. The legal documents (EULA, disclaimer, privacy policy, third-party notices) must be committed publicly because the in-app legal gate links to their GitHub URLs at first run. Also adds .gitignore, which the repo was missing. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> |
||
|
|
c395f976e5 | Initial commit |