pagespeed-quest 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -2,4 +2,15 @@
 
 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.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,48 @@ 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-install` | `psq` が動く状態のプロジェクトを用意する |
+| `psq-usage` | 記録 → ベースライン → 編集 → 計測のループ |
+| `psq-inventory` | ファイル構造と、施策ごとの編集レシピ |
+| `psq-video` | 読み込み過程のビフォーアフター動画 |
+
+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,49 @@ 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 inventory schema, the timing
+model, and a catalogue of which edit models which optimization:
+
+```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-install` | setting up a quest project so `psq` runs |
+| `psq-usage` | the record → baseline → edit → measure loop |
+| `psq-inventory` | the file layout and the catalogue of experiments |
+| `psq-video` | before/after videos of the load |
+
+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,264 @@
+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,
+                inventoryDir,
+                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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"}