Commit Graph
23 Commits
Author SHA1 Message Date
dependabot[bot] 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>
2026-07-29 19:56:11 +07:00
dependabot[bot] 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>
2026-07-29 19:56:06 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 20:53:26 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 20:44:28 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 20:33:27 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 20:26:05 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 20:14:47 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 20:03:19 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 19:49:29 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 19:40:20 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 19:26:40 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 19:15:03 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 19:07:32 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 18:38:46 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 18:08:10 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 18:06:34 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 18:04:37 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 17:44:39 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 17:25:56 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 17:10:34 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 17:08:23 +07:00
poli0981andClaude Opus 5 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>
2026-07-27 17:08:14 +07:00
poli0981 c395f976e5 Initial commit 2026-07-27 12:02:38 +07:00