Psalm Tester Laravel Package

Product Decisions This Supports

• Faster CI/CD feedback loops – Batch execution support enables parallelizable, targeted Psalm runs (per-file, per-service, or per-PR changes), reducing pipeline times by 30–50% for large codebases. Progress output (CLI args + test counts per group) further optimizes debugging and resource allocation.
• Granular, conditional static analysis – The --SKIPIF-- section introduces environment-aware execution (e.g., skip Psalm for dev branches or non-production environments), mirroring test suite flexibility and reducing noise in CI/CD.
• Developer productivity – Progress output (CLI args + group-by test counts) provides real-time visibility into Psalm runs, akin to test suites, and reduces debugging time for flaky or slow analyses.
• Shift-left quality gates – Batch execution enables incremental validation (e.g., "run Psalm only on modified files in a PR"), aligning with modern DevOps practices and reducing merge conflicts from type errors.
• Monorepo/microservices adoption – Grouped execution supports modular Psalm checks (e.g., per-service analysis in a monorepo or independent validation for microservices), improving scalability and maintainability.
• CI/CD cost optimization – Progress tracking and batching justify resource allocation for static analysis by demonstrating measurable improvements in pipeline efficiency and developer velocity.
• Enhanced observability – Progress output (e.g., runtime per group) allows teams to monitor Psalm performance trends over time, enabling data-driven optimizations.

When to Consider This Package

Adopt this package if:

• Your CI/CD pipeline is bottlenecked by Psalm runs, and you need batch execution to parallelize, subset, or conditionally skip analyses (e.g., per-file, per-service, or per-environment).
• You want test-like control over Psalm execution, including:
  • Conditional runs via --SKIPIF-- (e.g., skip for dev branches or non-production environments).
  • Progress output (CLI args + group-by test counts) for debugging and CI logging.
• You’re using Psalm in monorepos or microservices and need to run analyses on specific subsets of code (e.g., per-service or per-PR changes).
• Your team prioritizes developer experience and wants Psalm to feel as integrated and observable as unit tests (e.g., progress bars, group-by output).
• You lack dedicated tooling for Psalm parallelization and need a lightweight solution to optimize static analysis in CI/CD.
• You want real-time visibility into Psalm execution (e.g., runtime per group) to monitor performance trends and justify investment in static analysis.

Look elsewhere if:

• Your Psalm usage is already optimized (e.g., minimal runtime, no need for batching, conditionals, or progress tracking).
• You require advanced parallelization (e.g., custom worker pools, distributed execution) beyond this package’s batch/group support.
• Your CI/CD system already handles Psalm efficiently (e.g., pre-cached results, built-in parallelism, or third-party optimizations).
• You’re not using Psalm or lack buy-in for static analysis (this remains a wrapper, not a standalone tool).
• You need fine-grained control over Psalm’s internals (e.g., custom error handlers, plugin modifications) and prefer direct Psalm configuration.

How to Pitch It (Stakeholders)

For Executives: "This update transforms Psalm from a bottleneck into a scalable, observable quality gate. Batch execution lets us run static analysis only on changed files per PR, cutting pipeline time by 30–50% while maintaining type safety. The --SKIPIF-- feature ensures we skip unnecessary checks in non-production environments, and progress tracking provides real-time visibility—just like unit tests. It’s a low-effort way to accelerate development without sacrificing code quality, while also giving us data to optimize CI/CD costs over time."

For Engineering Leaders: *"The new batch execution, --SKIPIF-- support, and progress output let us treat Psalm like a test suite—run it conditionally, in parallel, or on subsets of code. Key wins:

• Faster PR feedback: Batch runs on only modified files (e.g., ./vendor/bin/psalm-tester --batch=modified), reducing pipeline time.
• Environment-aware checks: Skip Psalm for dev branches or non-production environments with --SKIPIF--.
• CI optimization: Progress output helps monitor Psalm performance over time, justifying investment in static analysis.
• Monorepo/microservices support: Run Psalm per-service or per-module for scalable validation. This turns Psalm into a first-class quality tool, not a bottleneck—while also giving us actionable metrics to refine our workflows."*

For Developers: *"Psalm just got way more useful in your workflow:

• Run Psalm on demand: ./vendor/bin/psalm-tester --batch=my-service (for microservices) or --batch=modified (for PRs).
• Skip checks when needed: --SKIPIF-- lets you exclude environments/branches (e.g., ./vendor/bin/psalm-tester --SKIPIF--="branch != main").
• See progress in real time: CLI output shows test counts and runtime per group, so you know exactly what’s being analyzed—just like phpunit.
• Monitor trends: Track Psalm performance over time to spot slowdowns early. Try it in your next PR—it’s Psalm, but faster, smarter, and more observable."*