pagespeed-quest 0.10.0 → 0.12.0

package/CHANGELOG.md

@@ -2,4 +2,28 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### 0.12.0 (2026-10-11)
+
+* **Lighthouse now reports the replay as observed** (`--throttling-method=provided`, plus `--throttling.requestLatencyMs=0`). Until now Lighthouse ran with its default `simulate` method, which re-derives every metric from its own network model and ignores the timing the proxy reproduces — reported FCP could even be shorter than the document's TTFB, and repeated runs of one recording disagreed by hundreds of milliseconds. **Scores and metrics change, and are not comparable with earlier versions.** A playback run now takes roughly 20–30 seconds, because Lighthouse waits for the page to go quiet
+* Restructure the Agent Skills bundle around a whole investigation of a URL. `psq-usage` now runs record → measure → investigate → one change per trial → adopt or reject → report, with `baseline/` (never edited), `accepted/` (adopted changes) and a `quest-log.md`; new `psq-record` (recording, checking it, freezing the baseline) and `psq-measure` (several runs per state with medians and spread, reading `lighthouse.report.json` for the LCP element, waterfall, script cost and third parties, screenshot diffs)
+* The skills and `llmdocs/20-experiments.md` no longer prescribe optimizations; they cover how an edit reaches the replay and what cannot be modelled, and leave the choice of changes to the agent
+* Document that the report written by `psq lighthouse recording` measured the live site and must not be used as the baseline
+* Fix the documented inventory layout: method directories are lower-case (`contents/get/…`), queries are URL-encoded before the extension, and `contentFilePath` is relative to the inventory directory
+* Document that `method`, `url` and `ttfbMs` are required when adding a resource to `index.json`
+* **Bundle rust-http-playback-proxy 0.11.1.** Recordings now carry `formatVersion: 2`: a resource you did not edit replays byte for byte as the site sent it, in the recorded time, and an edited one takes time proportional to its size on the wire at the recorded per-resource speed. Shrinking a file finally makes it arrive sooner. HTML is stored as recorded instead of reformatted, and the bytes that went over the wire are kept in `inventory/originals/` — do not edit them or the `original` field. Recordings made with earlier versions still replay as before (recorded duration whatever the size); re-record them to get size-proportional timing
+* The *Traffic* table in `summary.md` is now what the browser received in the run (Lighthouse's `network-requests`), not an estimate from fixed compression ratios; *Resource* is the decoded size from the same source
+* Windows (x64) gets a playback proxy built for this release; until now the npm package carried a v0.3.0 binary. **Intel Macs are no longer supported**: postinstall stops with `Unsupported platform` instead of downloading arm64 binaries that cannot run there
+* Fix the documentation of inline `contentUtf8` / `contentBase64`: they are used only when there is no `contentFilePath`, not in preference to the file
+
+### 0.11.0 (2026-08-16)
+
+* Add `psq llm` — the embedded reference for AI agents (`--format markdown|json`), sourced from `llmdocs/` and shipped with the package
+* Add `psq --version`
+* Ship an Agent Skills bundle (`plugins/pagespeed-quest/`): `psq-install`, `psq-usage`, `psq-inventory`, `psq-video`, installable through the ideamans Claude Code marketplace or `gh skill`
+* Add `context7.json` so agents with the context7 MCP server can look the project up
+* Generate `llmdocs/90-commands.md` from the actual command tree (`yarn ai:regen`), and fail the test suite when it is stale or when the skill bundle drifts
+* Extract the command tree into `src/cli.ts` (`createProgram()`); `src/command.ts` is now only the bin entry point
+* Publish to npm on a `v*` tag push instead of on every push to `main`, verifying the tag against `package.json` and the plugin manifest
+* Require Node.js 22.19 or newer (Lighthouse 13's floor); CI runs 22.x and 24.x
+
 ### 0.2.1 (2024-09-11)

package/README.ja.md

@@ -136,6 +136,53 @@ yarn psq proxy -p 8080 --record https://example.com/
 /Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --ignore-certificate-errors --proxy-server=http://localhost:8080
 ```
 
+## AIエージェントから使う
+
+PageSpeed Quest は、AIエージェント向けのリファレンスを自分で持っています。
+鉄則・調査の進め方・インベントリのスキーマ・再生時のタイミングの計算式・
+編集が再生にどう効くか・計測結果の読み方が、1コマンドで全部出ます。
+
+```sh
+yarn psq llm                # Markdown（既定）
+yarn psq llm --format json  # 章ごとのJSON配列
+```
+
+インストールされたパッケージに同梱されているので、**実行中のバージョンと必ず
+一致します**（ドキュメントサイトと違って古くなりません）。
+
+### Claude Code / gh skill
+
+`plugins/pagespeed-quest/` に Agent Skills を同梱しています。
+
+| スキル | 内容 |
+| --- | --- |
+| `psq-usage` | URL の調査を通しで行う。記録 → 計測 → ボトルネック調査 → 1つずつ試す → 効いたものを採用 → 改善幅を報告 |
+| `psq-install` | `psq` が動く状態のプロジェクトを用意する |
+| `psq-record` | ページを記録し、記録を点検し、ベースラインとして凍結する |
+| `psq-measure` | Lighthouse の複数回計測と中央値、レポートからボトルネックを読む、スクリーンショット比較 |
+| `psq-inventory` | 記録への編集が再生にどう効くか |
+| `psq-video` | 読み込み過程のビフォーアフター動画 |
+
+スキルが教えるのはツールの使い方で、Web 高速化の施策ではありません。
+何を改善するかはエージェントの判断に任せています。
+
+Claude Code の場合:
+
+```sh
+/plugin marketplace add ideamans/claude-public-plugins
+/plugin install pagespeed-quest
+```
+
+Copilot / Cursor / Gemini CLI / Codex などは同じ SKILL.md を `gh skill` で
+入れられます。
+
+```sh
+gh skill install ideamans/pagespeed-quest/plugins/pagespeed-quest/skills/psq-usage --agent copilot
+```
+
+[context7](https://context7.com/) にも登録しているので、context7 MCP を繋いだ
+エージェントは何も入れずに参照できます。
+
 ## 開発環境の共有やトレーニングにも
 
 PageSpeed Questは、Webアプリケーションのリリースを必要としないスピーディーな仮説検証以外にも有用です。

package/README.md

@@ -136,6 +136,55 @@ However, since this HTTP proxy uses a dummy SSL certificate, please disable the
 /Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --ignore-certificate-errors --proxy-server=http://localhost:8080
 ```
 
+## Driving it with an AI agent
+
+PageSpeed Quest ships its own reference for AI agents. One command prints
+everything an agent needs — the ground rules, the investigation loop, the
+inventory schema, the timing model, how an edit reaches the replay, and how to
+read the measurements:
+
+```sh
+yarn psq llm              # Markdown (default)
+yarn psq llm --format json  # one object per chapter
+```
+
+The reference is embedded in the installed package, so it always matches the
+version you are running.
+
+### Claude Code / gh skill
+
+The repository also ships an Agent Skills bundle under
+`plugins/pagespeed-quest/`:
+
+| Skill | What it covers |
+| --- | --- |
+| `psq-usage` | the whole investigation of a URL: record, measure, find bottlenecks, try changes one at a time, adopt what helps, report the gain |
+| `psq-install` | setting up a quest project so `psq` runs |
+| `psq-record` | recording a page, checking the recording, freezing the baseline |
+| `psq-measure` | repeated Lighthouse runs and medians, reading the report for bottlenecks, screenshot diffs |
+| `psq-inventory` | how an edit to the recording reaches the replay |
+| `psq-video` | before/after videos of the load |
+
+The skills teach the tool, not web performance: choosing what to optimize is
+left to the agent.
+
+For Claude Code, add the ideamans marketplace and install the plugin:
+
+```sh
+/plugin marketplace add ideamans/claude-public-plugins
+/plugin install pagespeed-quest
+```
+
+For other agents (Copilot, Cursor, Gemini CLI, Codex), the same skills install
+through `gh skill`:
+
+```sh
+gh skill install ideamans/pagespeed-quest/plugins/pagespeed-quest/skills/psq-usage --agent copilot
+```
+
+The project is also registered with [context7](https://context7.com/), so agents
+with the context7 MCP server can look it up without installing anything.
+
 ## For Sharing Development Environments and Training
 
 PageSpeed Quest is useful not only for speedy hypothesis verification without the need for a Web application release but also for other purposes.

package/build/cli.d.ts

@@ -0,0 +1,8 @@
+import { Command } from 'commander';
+/**
+ * Build the `psq` command tree.
+ *
+ * Exported so that scripts/build-llm-docs.js can walk it to generate the
+ * command catalog (llmdocs/90-commands.md) instead of hand-maintaining it.
+ */
+export declare function createProgram(): Command;

package/build/cli.js

@@ -0,0 +1,263 @@
+import Path from 'path';
+import { Command } from 'commander';
+import Watch from 'node-watch';
+import { Dependency } from './dependency.js';
+import { execLighthouse } from './lighthouse.js';
+import { packageVersion, renderLlmDocs } from './llm.js';
+import { execLoadshow } from './loadshow.js';
+import { execWebshotCapture, execWebshotCompare } from './webshot.js';
+import { InventoryRepository, withPlaybackProxy, withRecordingProxy } from './index.js';
+/**
+ * The dependency container is created lazily.
+ *
+ * Building it eagerly would spawn the pino-pretty transport worker as a side
+ * effect of importing this module, which breaks tools that only want to walk
+ * the command tree (see scripts/build-llm-docs.js).
+ */
+let dependencyInstance;
+function dependency() {
+    if (!dependencyInstance)
+        dependencyInstance = new Dependency();
+    return dependencyInstance;
+}
+function collect(value, previous) {
+    return previous.concat([value]);
+}
+function registerLighthouseCommands(main) {
+    const lighthouse = main.command('lighthouse');
+    lighthouse.description('Run Lighthouse (performance category) via a proxy');
+    lighthouse.option('-a, --artifacts <dir>', 'Artifacts directory', './artifacts');
+    lighthouse.option('-l, --laud', 'Show browser and open the report after completion', false);
+    lighthouse.option('-t, --timeout <ms>', 'Timeout milliseconds', '30000');
+    const recording = lighthouse.command('recording');
+    recording.description('Record contents by lighthouse');
+    recording.option('-d, --device <mobile|desktop>', 'Device type', 'mobile');
+    recording.option('-x, --exclude <pattern>', 'Regex patterns to exclude URLs from recording (repeatable)', collect, []);
+    recording.argument('<url>', 'Url to measure performance');
+    recording.action(async (url) => {
+        const inventoryRepository = new InventoryRepository(main.opts().inventory || './inventory');
+        const deviceType = recording.opts().device || 'mobile';
+        const artifactsDir = lighthouse.opts().artifacts || './artifacts';
+        const laud = !!lighthouse.opts().laud;
+        const timeout = Number(lighthouse.opts().timeout || '30000');
+        const excludePatterns = recording.opts().exclude || [];
+        await withRecordingProxy({
+            entryUrl: url,
+            deviceType,
+            inventoryRepository,
+            excludePatterns: excludePatterns.length > 0 ? excludePatterns : undefined,
+        }, dependency(), async (proxy) => {
+            await execLighthouse({
+                url,
+                proxyPort: proxy.port,
+                deviceType,
+                view: laud,
+                artifactsDir,
+                headless: !laud,
+                timeout,
+            }, dependency());
+            dependency().logger?.info('Lighthouse completed. Saving inventory...');
+        });
+    });
+    const playback = lighthouse.command('playback');
+    playback.description('Playback contents for lighthouse');
+    playback.action(async () => {
+        const inventoryDir = main.opts().inventory || './inventory';
+        const inventoryRepository = new InventoryRepository(inventoryDir);
+        const artifactsDir = lighthouse.opts().artifacts || './artifacts';
+        const laud = !!lighthouse.opts().laud;
+        const timeout = Number(lighthouse.opts().timeout || '30000');
+        // Load inventory for traffic statistics
+        const inventory = await inventoryRepository.loadInventory();
+        await withPlaybackProxy({
+            inventoryRepository,
+        }, dependency(), async (proxy) => {
+            await execLighthouse({
+                url: proxy.entryUrl,
+                proxyPort: proxy.port,
+                deviceType: proxy.deviceType,
+                view: laud,
+                artifactsDir,
+                headless: !laud,
+                timeout,
+                resources: inventory.resources,
+            }, dependency());
+            dependency().logger?.info('Lighthouse completed');
+        });
+    });
+}
+function registerLoadshowCommands(main) {
+    const loadshow = main.command('loadshow');
+    loadshow.description('Run loadshow via a proxy');
+    loadshow.option('-a, --artifacts <dir>', 'Artifacts directory', './artifacts');
+    loadshow.option('-c, --credit <string>', 'Credit string');
+    loadshow.option('-t, --timeout <ms>', 'Timeout milliseconds', '30000');
+    const recording = loadshow.command('recording');
+    recording.description('Record contents by loadshow');
+    recording.option('-d, --device <mobile|desktop>', 'Device type', 'mobile');
+    recording.option('-x, --exclude <pattern>', 'Regex patterns to exclude URLs from recording (repeatable)', collect, []);
+    recording.argument('<url>', 'Url to measure performance');
+    recording.action(async (url) => {
+        const inventoryRepository = new InventoryRepository(main.opts().inventory || './inventory');
+        const deviceType = recording.opts().device || 'mobile';
+        const artifactsDir = loadshow.opts().artifacts || './artifacts';
+        const credit = loadshow.opts().credit || '';
+        const timeout = Number(loadshow.opts().timeout || '30000');
+        const excludePatterns = recording.opts().exclude || [];
+        await withRecordingProxy({
+            entryUrl: url,
+            deviceType,
+            inventoryRepository,
+            excludePatterns: excludePatterns.length > 0 ? excludePatterns : undefined,
+        }, dependency(), async (proxy) => {
+            await execLoadshow({ url, proxyPort: proxy.port, deviceType, artifactsDir, credit, timeout }, dependency());
+            dependency().logger?.info('Loadshow completed. Saving inventory...');
+        });
+    });
+    const playback = loadshow.command('playback');
+    playback.description('Playback contents for loadshow');
+    playback.action(async () => {
+        const inventoryRepository = new InventoryRepository(main.opts().inventory || './inventory');
+        const artifactsDir = loadshow.opts().artifacts || './artifacts';
+        const credit = loadshow.opts().credit || '';
+        const timeout = Number(loadshow.opts().timeout || '30000');
+        await withPlaybackProxy({
+            inventoryRepository,
+        }, dependency(), async (proxy) => {
+            await execLoadshow({
+                url: proxy.entryUrl,
+                proxyPort: proxy.port,
+                deviceType: proxy.deviceType,
+                artifactsDir,
+                credit,
+                timeout,
+            }, dependency());
+            dependency().logger?.info('Loadshow completed');
+        });
+    });
+}
+function registerProxyCommands(main) {
+    const proxy = main.command('proxy');
+    proxy.description('Run the playback (or recording) proxy standalone');
+    proxy.option('-p, --port <number>', 'Proxy port', '8080');
+    proxy.option('-r, --record <url>', 'Recording URL to start the proxy as recording mode', '');
+    proxy.option('-x, --exclude <pattern>', 'Regex patterns to exclude URLs from recording (repeatable)', collect, []);
+    proxy.action(async () => {
+        const inventoryRepository = new InventoryRepository(main.opts().inventory || './inventory');
+        const port = Number(proxy.opts().port || '8080');
+        if (proxy.opts().record) {
+            const url = proxy.opts().record;
+            if (!url) {
+                throw new Error('Recording URL must be specified with --record option.');
+            }
+            const excludePatterns = proxy.opts().exclude || [];
+            // Recordingモード
+            await withRecordingProxy({
+                inventoryRepository,
+                port,
+                entryUrl: url,
+                excludePatterns: excludePatterns.length > 0 ? excludePatterns : undefined,
+            }, dependency(), async () => {
+                dependency().logger?.info(`Recording proxy started on port ${port}. Press Ctrl+C to stop.`);
+                // Wait for Ctrl+C signal
+                return new Promise((resolve) => {
+                    process.on('SIGINT', () => {
+                        dependency().logger?.info('Saving the inventory...');
+                        resolve();
+                    });
+                });
+            });
+        }
+        else {
+            // Playbackモード
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                await withPlaybackProxy({ inventoryRepository, port }, dependency(), async () => {
+                    const watcher = Watch(inventoryRepository.dirPath, { recursive: true });
+                    return new Promise((ok) => {
+                        watcher.on('change', () => {
+                            watcher.close();
+                            dependency().logger?.info('Inventory changed. Restarting proxy...');
+                            ok();
+                        });
+                    });
+                });
+            }
+        }
+    });
+}
+function registerCaptureCommands(main) {
+    const visualTest = main.command('capture');
+    visualTest.description('Capture a screenshot via playback proxy and optionally compare with a baseline');
+    visualTest.option('-a, --artifacts <dir>', 'Artifacts directory', './artifacts');
+    visualTest.option('-t, --timeout <ms>', 'Timeout milliseconds', '30000');
+    visualTest.option('--compare <file>', 'Baseline PNG file to compare against');
+    visualTest.option('--baseline-label <label>', 'Label for the baseline image', '前回');
+    visualTest.option('--current-label <label>', 'Label for the current image', '今回');
+    visualTest.action(async () => {
+        const inventoryRepository = new InventoryRepository(main.opts().inventory || './inventory');
+        const artifactsDir = visualTest.opts().artifacts || './artifacts';
+        const timeout = Number(visualTest.opts().timeout || '30000');
+        const compareFile = visualTest.opts().compare;
+        const baselineLabel = visualTest.opts().baselineLabel || '前回';
+        const currentLabel = visualTest.opts().currentLabel || '今回';
+        await withPlaybackProxy({
+            inventoryRepository,
+            fullThrottle: true,
+        }, dependency(), async (proxy) => {
+            const outputPath = Path.join(artifactsDir, 'capture.png');
+            await dependency().mkdirp(artifactsDir);
+            await execWebshotCapture({
+                url: proxy.entryUrl,
+                proxyPort: proxy.port,
+                preset: proxy.deviceType === 'desktop' ? 'desktop' : 'mobile',
+                output: outputPath,
+                timeout,
+            }, dependency());
+            dependency().logger?.info(`Screenshot saved to ${outputPath}`);
+            if (compareFile) {
+                const diffOutput = Path.join(artifactsDir, 'capture-diff.png');
+                const digestTxt = Path.join(artifactsDir, 'capture-diff.txt');
+                await execWebshotCompare({
+                    baseline: compareFile,
+                    current: outputPath,
+                    output: diffOutput,
+                    digestTxt,
+                    baselineLabel,
+                    currentLabel,
+                }, dependency());
+                dependency().logger?.info(`Diff image saved to ${diffOutput}`);
+                dependency().logger?.info(`Diff digest saved to ${digestTxt}`);
+            }
+        });
+    });
+}
+function registerLlmCommands(main) {
+    const llm = main.command('llm');
+    llm.description('Print the embedded reference for AI agents');
+    llm.option('-f, --format <markdown|json>', 'Output format', 'markdown');
+    llm.action(async () => {
+        const format = llm.opts().format === 'json' ? 'json' : 'markdown';
+        process.stdout.write(await renderLlmDocs(format));
+    });
+}
+/**
+ * Build the `psq` command tree.
+ *
+ * Exported so that scripts/build-llm-docs.js can walk it to generate the
+ * command catalog (llmdocs/90-commands.md) instead of hand-maintaining it.
+ */
+export function createProgram() {
+    const main = new Command();
+    main.name('psq');
+    main.version(packageVersion(), '-v, --version', 'Output the version number');
+    main.description('Record a web page through a proxy, edit the recording, and replay it to measure the difference');
+    main.option('-i, --inventory <dir>', 'Inventory directory', './inventory');
+    registerLighthouseCommands(main);
+    registerLoadshowCommands(main);
+    registerProxyCommands(main);
+    registerCaptureCommands(main);
+    registerLlmCommands(main);
+    return main;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":"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"}