Toolip v2.2.1 — Resolved Dependency Health

Toolip v2.2.1 — Resolved Dependency Health

Toolip v2.2.1 is a correctness release that closes the dependency-graph split left in v2.2.0. Dependency health used by toolip scan, toolip doctor, and toolip score now consumes the same exact resolved npm lockfile inventory used by vulnerability analysis, dependency trees, SBOM generation, install-script analysis, and reachability.

What changed

• Dependency health now analyzes the full resolved dependency inventory, including transitive packages, rather than only direct package.json declarations.
• Installed versions come from package-lock.json as exact resolved versions. Manifest ranges and specifiers such as ^1.2.3, workspace:*, latest, npm aliases, and Git specifiers are no longer treated as installed versions for health analysis.
• Deprecated, outdated, stale, and no-maintainer signals can now surface from transitive dependencies and participate in the dependency-health score.
• Registry analysis is deduplicated by exact name@version, avoiding duplicate lookups and duplicate score penalties when the same resolved package version is installed at multiple paths.
• totalDependencies now reflects the full resolved installed dependency graph rather than the much smaller direct-dependency set.
• Dependency finding IDs include the resolved package version, preventing collisions when multiple versions of the same package are installed.
• npm workspace link entries are resolved to their exact workspace package identity and version instead of being skipped.

Additional hardening

• Toolip now warns when multiple supported package-manager lockfiles coexist in a project instead of silently selecting one. The existing deterministic precedence remains pnpm > yarn > npm.
• Secret SHA-256 fingerprints are now explicitly documented as stable correlation/redaction metadata, not as a password hash, commitment, authentication primitive, or security boundary. Low-entropy values may be guessable from a fingerprint and the fingerprint should remain sensitive report metadata.
• The trusted npm publishing workflow can now publish a verified release commit from main automatically while remaining idempotent if that exact package version already exists.

Why this matters

Before v2.2.1, Toolip's OSV vulnerability path and its dependency-maintenance scoring path could describe different dependency universes: vulnerabilities came from the complete resolved graph, while maintenance and freshness signals came from direct manifest declarations. That could hide important transitive deprecations or staleness and make dependency summaries misleadingly small.

v2.2.1 makes the release's dependency-graph guarantee true end to end: the security score and dependency findings now reason about resolved package versions from the same canonical inventory as the rest of Toolip's supply-chain analysis.

Verification

The release adds regression coverage for:

• deep transitive dependency health
• exact resolved versions versus non-semver manifest specifiers
• multiple installed versions of one transitive package
• npm workspace link resolution
• multiple package-manager lockfile warnings

The release candidate must also pass Toolip's existing compiler-backed quality checks, production dependency audit, full Vitest suite, security-critical coverage gates, clean TypeScript build, packed-artifact verification, and isolated tarball installation checks before publication.

Toolip v2.2.0 — Security Hardening & Release Trust

Toolip v2.2.0 — Security Hardening & Release Trust

Toolip v2.2.0 is a broad hardening release focused on one goal: make every security claim, filesystem boundary, dependency identity, execution path, and release artifact more trustworthy while reducing unnecessary work inside the CLI.

This release follows a repository-wide security, correctness, first-principles engineering, and efficiency audit. The fixes were implemented as isolated issues/PRs, validated against the complete cross-platform CI matrix, and consolidated into the v2.2.0 release.

Security boundaries

MCP workspace containment

MCP tools that accept a project root now enforce the configured workspace boundary using canonical filesystem paths.

• requested roots are resolved through realpath() before authorization
• .. traversal outside an approved workspace is rejected
• symlink escapes are rejected after canonical resolution
• authorization uses path containment rather than unsafe string-prefix checks
• the MCP surface remains read-only and does not expose arbitrary shell execution

Secret evidence and detection

Secret scanning now treats findings as security facts rather than display strings.

• every supported same-rule secret occurrence in a file can produce its own finding
• finding identity is stable per occurrence instead of colliding at rule/file level
• raw token fragments are no longer exposed as report evidence by default
• deterministic fingerprints can correlate findings without publishing the secret
• test files are no longer blanket-downgraded merely because of their path
• explicit synthetic fixtures can still be marked intentionally
• Git-history scanning applies the same safer redaction/fixture model

Toolip Vault

Vault persistence and export were hardened without breaking the existing encrypted format.

• POSIX shell export now uses safe single-quote encoding
• $, $(...), backticks, backslashes, quotes, spaces, and newlines remain literal when sourced
• shell environment-variable key validation occurs at export time, preserving JSON/storage compatibility
• vault writes are serialized with a local lock to prevent lost updates
• encrypted updates use a temporary same-directory file followed by atomic rename
• valid older vaults have restrictive POSIX permissions repaired when read or written
• malformed JSON/schema/base64/decrypted payloads fail through controlled Toolip errors
• the current AES-256-GCM + scrypt version-1 encrypted format remains compatible

Correctness

Truthful security scoring

The scorecard no longer treats missing analysis as perfect security.

Toolip now distinguishes measured dimensions from unavailable, failed, timed-out, or cancelled analysis. An analyzer/provider that did not produce evidence cannot silently turn into 100/100.

Dependency scoring is also based on actual vulnerability analysis rather than assuming a zero vulnerability penalty when OSV was never consulted.

One canonical finding model

Toolip now uses one internal normalized Finding contract for security analysis. Legacy report compatibility is handled at serialization/output boundaries instead of maintaining a second security fact model throughout the codebase.

This reduces conversion paths and prevents different commands from interpreting the same security fact differently.

Correct resolved dependency graph

The dependency model now represents the lockfile rather than npm's physical hoisting layout.

• direct dependencies come from root manifest/lock declarations
• a transitive dependency hoisted to root node_modules is no longer misclassified as direct
• exact package installation paths are retained
• nested/duplicate versions remain distinguishable
• dependency edges are resolved using nearest node_modules semantics
• toolip tree now represents real resolved relationships instead of placeholder empty children
• install-script analysis reads the exact resolved package instance
• CycloneDX/SPDX relationships and dependency analysis reuse the same graph

Execution reliability and scale

Single project discovery context

Repository discovery is now reused instead of repeatedly walking the entire tree inside one command.

This removes duplicated work from Doctor, pre-commit, AST, reachability, Docker, and other analysis paths.

Toolip also tracks discovered/scanned/skipped/failed file counts accurately rather than counting unreadable files as successfully scanned.

Scan budgets and bounded reads

Source analyzers no longer blindly read arbitrary files in full.

• file-count and byte budgets bound repository work
• oversized/binary-like files are skipped intentionally
• file reads are bounded
• analyzers can reuse the shared project inventory
• Git-history analysis processes output incrementally instead of buffering the full patch history
• Dockerfile analysis uses a single indexed pass, preserving correct line numbers for repeated lines

AnalyzerRunner hardening

The analyzer execution layer now guarantees more than a cooperative AbortSignal.

• hard deadlines terminate the runner's wait even when an analyzer ignores cancellation
• sibling analyzer failures do not discard successful results
• timeout/failure/cancellation state is explicit
• results retain deterministic input order
• provider/package fan-out uses bounded concurrency
• OSV requests are deduplicated by exact package/version
• vulnerability correlation uses indexed lookups instead of repeated linear scans
• the misleading process-local six-hour CLI cache was removed rather than pretending it survived process exit

Safer Git/developer workflows

Non-destructive hooks

toolip hook install no longer overwrites an existing pre-commit hook. Toolip preserves existing hook logic and manages its own integration explicitly.

Staged pre-commit analysis

Pre-commit mode scans the staged change set by default. Existing unrelated repository findings do not block a commit unless the user explicitly requests a full scan.

Transactional upgrade PRs

toolip upgrade-pr now performs mutable upgrade/test operations in an isolated temporary Git worktree.

• the user's current branch is not switched
• dirty files in the caller's worktree are preserved
• failures clean up the temporary worktree
• invalid versions are rejected before mutation
• branch collisions are handled deliberately
• npm, pnpm, and Yarn projects use package-manager-aware lockfile update behavior

Resilient watch mode

Watch mode now reports analysis callback failures and continues monitoring instead of producing an unhandled rejection.

Node 24 on Windows also exposed a native libuv assertion in recursive fs.watch. Toolip now uses a managed non-recursive directory-watcher tree on Windows instead of depending on that crashing recursive path, while retaining debounce, queueing, ignore rules, and recovery semantics.

Package metadata and provider trust

License facts now come from deps.dev for the exact resolved direct-dependency version instead of a hard-coded map containing only a handful of package names.

Provider failures are explicit. Toolip does not silently substitute guessed license facts when authoritative metadata is unavailable.

Testing and engineering quality

v2.2.0 removes low-value tests that inspected src/index.ts for registration strings and replaces them with behavioral Commander command-tree assertions.

The CLI entrypoint is now intentionally small; program composition lives in a reusable createProgram() function.

The verification pipeline adds:

• Node.js runtime declaration: >=22 <25
• Node 22 and Node 24 CI coverage
• Ubuntu, macOS, and Windows execution for every supported Node major
• compiler-backed static quality checks (noUnusedLocals, noUnusedParameters, noImplicitReturns, noFallthroughCasesInSwitch)
• production dependency auditing at high severity
• official Vitest V8 coverage for security-critical modules
• minimum security-critical coverage floors of 75% statements/lines, 65% branches, and 85% functions

During the release hardening work, npm's production graph exposed transitive advisories. The lockfile was refreshed within compatible dependency ranges and the release verification now reports zero npm vulnerabilities.

Release trust

Toolip continues to verify the package users actually install, not merely the source tree.

npm run release:check validates quality gates, runtime dependency audit, tests/coverage, a clean build, required npm package contents, the executable shebang, packed tarball installation, and packaged CLI execution.

v2.2.0 also introduces a least-privilege GitHub Actions release path:

• normal CI has read-only repository permissions
• npm publishing is separate from CI
• the preferred publish flow uses npm trusted publishing/OIDC rather than exposing a long-lived token to build jobs
• the npm publish job is manual, restricted to main, version-checked, confirmation-gated, and compatible with a protected npm-release environment
• GitHub release/tag creation is performed from the verified main release commit and the checked-in release notes

Compatibility

• Toolip v2.2.0 supports Node.js 22 and 24.
• Existing valid Toolip Vault v1 files remain supported.
• Existing report consumers retain the legacy serialized report shape where compatibility is required even though the internal finding model is unified.
• Remote GitHub operations remain opt-in and use the user's own authorization.

Verification

The release candidate is required to pass:

• changelog verification
• compiler-backed quality checks
• production npm audit gate
• complete test suite
• security-critical V8 coverage thresholds
• Node 22 and 24 on Ubuntu
• Node 22 and 24 on macOS
• Node 22 and 24 on Windows
• clean production build
• built-package verification
• npm tarball content verification
• isolated tarball installation
• packaged toolip --version
• packaged `toolip sel...

Toolip v2.1.1 — Unified Dependency Health Scoring

Toolip v2.1.1 unifies dependency-health scoring across the CLI.

Toolip v2.1.0 introduced the new risk-aware scoring model, but toolip score and toolip scan still calculated dependency health through separate paths. That could cause both commands to report slightly different values for the same project.

Fixed:

• toolip scan and toolip score now consume the same canonical dependency-health result.
• Dependency health is calculated once inside the dependency-scanning service.
• The old finding-based calculation is no longer used by the scan command.
• Both commands now report an identical dependency-health score for the same project state.
• Added regression tests preventing future scoring-path divergence.

Verification:

• TypeScript typecheck passed.
• Complete test suite passed.
• Clean production build passed.
• Changelog validation passed.
• npm package-content verification passed.
• Tarball inspection passed.
• Isolated package installation passed.
• CLI version, self-test, help, scan, and score checks passed.

Built by Ashibuogwu Williams (wbizmo).

Toolip v2.1.0 — Risk-Aware Dependency Scoring

Toolip v2.1.0

Toolip v2.1.0 introduces a risk-aware dependency-health scoring model.

The previous score treated every outdated dependency as a medium-severity finding worth a 12-point penalty. A project with 11 outdated packages could therefore accumulate 132 points of penalties and be clamped to 0/100, even when OSV reported zero disclosed vulnerabilities.

This release replaces that behavior.

Changed

• Disclosed vulnerabilities now carry the strongest dependency-health penalties.
• Deprecated packages, missing maintainer metadata, stale publishing activity, and outdated versions are scored as separate signals.
• Major, minor, and patch-level version gaps now receive different weights.
• Patch-level update lag receives a minimal fractional penalty.
• Freshness penalties are capped at 15 points.
• Maintenance penalties are capped at 20 points.
• Deprecation penalties are capped at 40 points.
• Outdated packages alone can no longer reduce dependency health to zero.
• toolip score now prints the dependency-health penalty breakdown.
• toolip score --json now returns structured score and penalty details.

Fixed

• Fixed the reproduced case where Toolip reported Dependency Health: 0 despite having zero disclosed vulnerabilities.
• Removed the assumption that an outdated package is equivalent to a medium-severity security vulnerability.
• Added regression coverage using the exact pattern of 11 outdated dependencies that exposed the flaw.

Verification

• TypeScript typecheck passed.
• Complete test suite passed.
• Clean production build passed.
• Changelog verification passed.
• npm tarball validation passed.
• Isolated package installation passed.
• CLI version, self-test, help, and score command checks passed.

Built by Ashibuogwu Williams (wbizmo).

Toolip v2.0.1 — Git History Fixture Accuracy

Toolip v2.0.1

Toolip v2.0.1 improves the accuracy and consistency of Git-history secret scanning.

Fixed

• Password-like values committed inside test files are now classified as low-severity potential test fixtures.
• Git-history findings now retain the historical source file path.
• Test fixtures use medium confidence and fixture-specific remediation guidance.
• Genuine credentials outside test files retain their original high or critical severity.
• Redacted evidence and secret fingerprints remain unchanged.

Verification

• TypeScript typecheck passed.
• Complete test suite passed.
• Clean production build passed.
• Package-content verification passed.
• CLI version, self-test, help output, and Git-history command checks passed.

Built by Ashibuogwu Williams (wbizmo).

Toolip v2.0.0 — Developer Security Platform

Toolip v2.0.0

Toolip v2.0.0 turns the original developer security CLI into a broader local-first security platform for JavaScript and TypeScript projects.

Vulnerability and dependency intelligence

• Added OSV.dev matching for disclosed vulnerabilities against exact npm package versions.
• Added deps.dev package metadata, dependency graph, provenance, attestation, license, and advisory intelligence.
• Added package reachability evidence based on JavaScript and TypeScript imports.
• Added dependency-confusion checks for internal-looking package names that collide with public npm packages.
• Added install-script analysis for suspicious network, shell, filesystem, obfuscation, and environment-access behavior.
• Added CycloneDX 1.5 and SPDX 2.3 SBOM generation.

Source and application security

• Added TypeScript Compiler API analysis for supported dangerous-code patterns.
• Distinguished RegExp.exec() from resolved child_process.exec() calls.
• Added stable rule IDs, normalized findings, confidence levels, evidence, remediation, and machine-readable metadata.
• Added configurable rule severity, path policy, suppressions, provider settings, and history retention through toolip.config.json.

Git, repository, and delivery security

• Added full Git-history secret scanning with redacted evidence and fingerprints.
• Added security-relevant diffs between Git revisions.
• Added remote public GitHub repository auditing through the authenticated gh CLI.
• Added tested dependency-upgrade pull-request generation.
• Added Dockerfile checks for root execution, embedded secrets, unpinned images, remote downloads, and package cleanup.
• Added npm and pnpm monorepo workspace discovery.

Developer workflows

• Added local security history and score trends.
• Added static HTML security report generation.
• Added real-time watch mode.
• Added deterministic local security announcement generation.
• Added a read-only MCP server for security doctor, SBOM, and Git diff operations.

Release engineering

• package.json remains the single source of version truth.
• Releases are checked through typechecking, the complete test suite, a clean production build, package-content validation, npm tarball inspection, isolated tarball installation, CLI version verification, self-test, and help output.
• The release process blocks publication when the compiled CLI, README, license, executable shebang, version synchronization, or required package contents are missing.

Installation

npm install -g toolip@2.0.0

Verification

toolip --version
toolip self-test
toolip --help

Built by Ashibuogwu Williams (wbizmo).

Toolip v1.0.7 — Package Recovery and Scanner Accuracy

Toolip v1.0.7 restores a fully functional npm package and hardens the release pipeline.

Critical fix:

• Restores the compiled dist/src CLI files missing from v1.0.6.
• Verifies the actual npm tarball contains the executable before publication.
• Installs and runs the packed tarball in an isolated environment before release.
• Adds a mandatory prepack build and package verification step.

Accuracy fixes:

• Uses package.json as the single source of truth for the CLI version.
• Prevents RegExp.exec() from being reported as child_process.exec().
• Restricts dangerous-code detection to executable source files.
• Prevents JSON reports containing prior findings from being rescanned as executable vulnerabilities.
• Downgrades password-like test fixtures to low severity.
• Retains detection of genuine shell exec() calls.

Verification:

• TypeScript typecheck passes.
• Full Vitest suite passes.
• Clean production build passes.
• Package structure verification passes.
• Packed tarball installation passes.
• CLI version, help, and self-test pass from the packed artifact.

Built by Ashibuogwu Williams (wbizmo).

Toolip v1.0.6 — Scanner Accuracy and Version Consistency

Toolip v1.0.6 improves scanner accuracy and removes duplicated version state.

Fixes:

• Uses package.json as the single source of truth for Toolip's version.
• Ensures toolip --version, self-test output, reports, and published package metadata remain synchronized.
• Prevents RegExp.exec() from being incorrectly reported as unsafe child_process.exec() usage.
• Preserves detection of genuine direct shell exec() calls.
• Downgrades password-like values in test fixtures to low severity instead of reporting them as high-severity production credentials.
• Adds regression tests for scanner accuracy and version synchronization.

Verification:

• TypeScript typecheck passes.
• Full Vitest suite passes.
• Production build passes.
• CLI self-test passes.
• npm package preview succeeds.

Built by Ashibuogwu Williams (wbizmo).

Toolip v1.0.5

Documentation release.

Updates:

• Publishes README to the npm package.
• Improves npm package presentation.
• Keeps the latest published package documentation in sync with GitHub.

Toolip v1.0.4

Documentation release.

Updates:

• Adds the full README to the published npm package.
• Improves npm package presentation and usage documentation.