Release Pressship 0.1.9

Author: f

README.md

@@ -52,8 +52,8 @@ npx pressship login
 # 2. (Optional) Verify the saved session
 npx pressship whoami
 
-# 3. Validate, package, and check without uploading
-npx pressship publish ./my-plugin --dry-run
+# 3. Verify the plugin without packaging or uploading
+npx pressship verify ./my-plugin
 
 # 4. Submit for review or release an approved plugin
 npx pressship publish ./my-plugin
@@ -96,6 +96,7 @@ Playwright Chromium is installed automatically the first time browser automation
 | `pressship get` | Checkout or update a WordPress.org plugin SVN working copy. |
 | `pressship status` | Read review state from the logged-in developer dashboard. |
 | `pressship version <patch\|minor\|major>` | Bump the plugin header version and readme stable tag together. |
+| `pressship verify` | Run readme validation and Plugin Check without creating a zip. |
 | `pressship pack` | Validate, run Plugin Check, and write an installable zip. |
 | `pressship publish` | Route to submit or release based on current state. |
 | `pressship submit` | Upload a zip to WordPress.org review (or reupload). |
@@ -149,6 +150,19 @@ Need fine-grained control? Use the explicit subcommands `submit` and `release`.
 
 ## Packaging
 
+```bash
+pressship verify ./my-plugin
+```
+
+Runs readme validation and Plugin Check without writing a zip or publishing anything.
+
+```bash
+pressship verify ./my-plugin --ignore "assets/**/*.mp4"
+pressship verify ./my-plugin --skip-readme-validator
+pressship verify ./my-plugin --wp-path /path/to/wordpress
+pressship verify ./my-plugin --json
+```
+
 ```bash
 pressship pack ./my-plugin
 ```

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "pressship",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "Submit and release WordPress.org plugins from the command line.",
   "homepage": "https://pressship.org",
   "bin": {

package.json

@@ -4,6 +4,7 @@ import { login } from "./auth/login.js";
 import { logout } from "./auth/logout.js";
 import { whoami, type WhoamiOptions } from "./auth/whoami.js";
 import { pack, type PackOptions } from "./package/pack.js";
+import { verify, type VerifyOptions } from "./package/verify.js";
 import { publish, type PublishOptions } from "./wordpress-org/publish.js";
 import { submit, type SubmitOptions } from "./wordpress-org/submit.js";
 import { status, type StatusOptions } from "./wordpress-org/state.js";
@@ -98,6 +99,16 @@ program
   .option("-y, --yes", "Continue without interactive confirmations where possible")
   .action((pluginPath: string | undefined, options: PublishOptions) => run(() => publish(pluginPath, options))());
 
+program
+  .command("verify")
+  .description("Run readme validation and Plugin Check without packaging or publishing.")
+  .argument("[plugin-path]", "Path to the WordPress plugin directory")
+  .option("--ignore <glob>", "Ignore files while staging Plugin Check; repeat for multiple globs", collectValues, [])
+  .option("--skip-readme-validator", "Skip the remote WordPress.org readme validator")
+  .option("--wp-path <path>", "WordPress installation path for `wp plugin check`")
+  .option("--json", "Print verification details as JSON")
+  .action((pluginPath: string | undefined, options: VerifyOptions) => run(() => verify(pluginPath, options))());
+
 program
   .command("pack")
   .description("Create a WordPress-installable plugin zip, similar to npm pack.")

src/cli.ts

@@ -0,0 +1,83 @@
+import path from "node:path";
+import { z } from "zod";
+import { hasBlockingFindings, printFindings } from "../checks/summary.js";
+import { discoverPluginProject } from "../plugin/discover.js";
+import type { PluginProject } from "../types.js";
+import { ui } from "../ui.js";
+import { validatePluginPack, type PackValidationResult } from "./pack.js";
+
+const verifyOptionsSchema = z.object({
+  ignore: z.array(z.string()).default([]),
+  skipReadmeValidator: z.boolean().default(false),
+  wpPath: z.string().optional(),
+  json: z.boolean().default(false)
+});
+
+export type VerifyOptions = z.input<typeof verifyOptionsSchema>;
+
+export type VerifySummary = {
+  ok: boolean;
+  plugin: {
+    rootDir: string;
+    mainFile: string;
+    name: string;
+    slug: string;
+    version?: string;
+    readmePath?: string;
+  };
+  validation: PackValidationResult;
+};
+
+export async function verify(pluginPath: string | undefined, rawOptions: VerifyOptions): Promise<void> {
+  const options = verifyOptionsSchema.parse(rawOptions);
+
+  if (!options.json) {
+    ui.intro("Verify WordPress plugin");
+  }
+
+  const rootDir = path.resolve(pluginPath ?? process.cwd());
+  const project = options.json
+    ? await discoverPluginProject(rootDir)
+    : await ui.task("Discovering WordPress plugin", () => discoverPluginProject(rootDir), (value) =>
+        `Discovered ${value.headers.pluginName}`
+      );
+  const validation = options.json
+    ? await validatePluginPack(project, options)
+    : await ui.task("Verifying plugin", () => validatePluginPack(project, options));
+  const summary = summarizeVerifyResult(project, validation);
+
+  if (options.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    if (!summary.ok) {
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  printFindings("Readme validation", validation.readmeFindings);
+  printFindings("Plugin Check", validation.pluginCheckFindings);
+
+  if (!summary.ok) {
+    throw new Error("Verification reported blocking findings.");
+  }
+
+  ui.success("Verification passed.");
+}
+
+export function summarizeVerifyResult(
+  project: PluginProject,
+  validation: PackValidationResult
+): VerifySummary {
+  return {
+    ok: !hasBlockingFindings(validation.readmeFindings) && !hasBlockingFindings(validation.pluginCheckFindings),
+    plugin: {
+      rootDir: project.rootDir,
+      mainFile: project.mainFile,
+      name: project.headers.pluginName,
+      slug: project.slug,
+      version: project.version,
+      readmePath: project.readmePath
+    },
+    validation
+  };
+}

src/package/verify.ts

@@ -4,6 +4,7 @@ import path from "node:path";
 import { describe, expect, it } from "vitest";
 import { createPluginZip, listPackageFiles, stagePluginDirectory } from "../src/package/archive.js";
 import { createPluginPack, skippedPackValidation, summarizePackResult, validatePluginPack } from "../src/package/pack.js";
+import { summarizeVerifyResult } from "../src/package/verify.js";
 import { discoverPluginProject, resolvePluginProjectPath } from "../src/plugin/discover.js";
 import { parsePluginHeaders } from "../src/plugin/headers.js";
 import { parseReadme, validateReadmeLocally } from "../src/plugin/readme.js";
@@ -216,6 +217,49 @@ describe("packaging", () => {
   });
 });
 
+describe("verification", () => {
+  it("summarizes successful verification results", async () => {
+    const root = await samplePlugin();
+    const project = await discoverPluginProject(root);
+
+    expect(summarizeVerifyResult(project, skippedPackValidation())).toMatchObject({
+      ok: true,
+      plugin: {
+        rootDir: root,
+        mainFile: path.join(root, "example-plugin.php"),
+        name: "Example Plugin",
+        slug: "example-plugin",
+        version: "1.2.3",
+        readmePath: path.join(root, "readme.txt")
+      },
+      validation: {
+        skipped: true,
+        readmeFindings: [],
+        pluginCheckFindings: []
+      }
+    });
+  });
+
+  it("marks blocking verification findings as not ok", async () => {
+    const root = await samplePlugin();
+    const project = await discoverPluginProject(root);
+
+    expect(
+      summarizeVerifyResult(project, {
+        skipped: false,
+        readmeFindings: [
+          {
+            severity: "error",
+            code: "readme.invalid",
+            message: "Readme is invalid."
+          }
+        ],
+        pluginCheckFindings: []
+      }).ok
+    ).toBe(false);
+  });
+});
+
 describe("version bumps", () => {
   it("bumps semver patch, minor, and major", () => {
     expect(bumpVersion("1.2.3", "patch")).toBe("1.2.4");

tests/plugin.test.ts

@@ -0,0 +1,28 @@
+---
+sidebar_position: 6
+---
+
+# Verify
+
+```bash
+npx pressship verify ./my-plugin
+```
+
+`verify` runs Pressship's publishing checks without creating a zip, uploading a submission, or touching SVN.
+
+It checks:
+
+- local `readme.txt` metadata;
+- the remote WordPress.org readme validator;
+- the official WordPress.org Plugin Check.
+
+The command exits with a non-zero status when blocking findings are reported.
+
+## Options
+
+```bash
+pressship verify ./my-plugin --ignore "assets/**/*.mp4"
+pressship verify ./my-plugin --skip-readme-validator
+pressship verify ./my-plugin --wp-path /path/to/wordpress
+pressship verify ./my-plugin --json
+```

website/docs/commands/verify.md

@@ -33,10 +33,11 @@ npx pressship status ./my-plugin
 ## Package And Validate
 
 ```bash
+npx pressship verify ./my-plugin
 npx pressship pack ./my-plugin
 ```
 
-`pack` validates `readme.txt`, runs Plugin Check, and writes a WordPress-installable `{slug}.zip` to the current directory.
+`verify` validates `readme.txt` and runs Plugin Check without creating an artifact. `pack` runs the same checks and writes a WordPress-installable `{slug}.zip` to the current directory.
 
 ## Publish
 

website/docs/getting-started.md

@@ -20,6 +20,7 @@ It can automatically:
 This means most users can run:
 
 ```bash
+pressship verify ./my-plugin
 pressship submit ./my-plugin --dry-run
 ```
 
@@ -29,6 +30,7 @@ If you already have a local WordPress install with Plugin Check available, pass
 
 ```bash
 pressship submit ./my-plugin --wp-path /path/to/wordpress
+pressship verify ./my-plugin --wp-path /path/to/wordpress
 pressship pack ./my-plugin --wp-path /path/to/wordpress
 pressship release ./my-plugin --wp-path /path/to/wordpress
 ```

website/docs/guides/plugin-check.md

@@ -20,6 +20,7 @@ npx pressship publish ./my-plugin
 - Plugin discovery from WordPress plugin headers.
 - `readme.txt` parsing and WordPress.org readme validation.
 - Managed WordPress.org Plugin Check setup.
+- Standalone `verify` checks before packaging or publishing.
 - WordPress-installable zip generation.
 - Smart `publish` routing between review submission and SVN release.
 - Explicit `submit` and `release` commands for WordPress.org workflows.