ci-cost-diff-action 0.1.0

package/bin/ci-cost-diff.js

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { analyzeJobs, diffSummaries, evaluateThresholds } from "../src/cost.js";
+import { parseBoolean, parseJsonObject, parseList } from "../src/inputs.js";
+import { renderReport } from "../src/report.js";
+
+const VALUE_OPTIONS = new Set([
+  "current",
+  "baseline",
+  "rates",
+  "exclude",
+  "fail-on-increase-percent",
+  "fail-on-increase-usd",
+  "fail-on-total-usd"
+]);
+
+const BOOLEAN_OPTIONS = new Set([
+  "fail-on-unknown-runner",
+  "fail-on-ambiguous-runner-rate"
+]);
+
+try {
+  run();
+} catch (error) {
+  console.error(`error: ${error.message ?? error}`);
+  process.exitCode = 1;
+}
+
+function run() {
+  const argv = process.argv.slice(2);
+  if (argv.includes("--help")) {
+    printHelp();
+    process.exitCode = 0;
+    return;
+  }
+
+  const args = parseArgs(argv);
+
+  if (!args.current) {
+    printHelp();
+    process.exitCode = 1;
+    return;
+  }
+
+  const analysis = analyzeCliJobs(args);
+  const thresholdResult = evaluateCliThresholds(args, analysis);
+  const runnerRateWarnings = collectRunnerRateWarnings(analysis);
+  const report = renderCliReport({ args, analysis, thresholdResult, runnerRateWarnings });
+
+  process.stdout.write(report);
+
+  if (thresholdResult.conclusion === "fail") {
+    process.exitCode = 1;
+  }
+}
+
+function analyzeCliJobs(args) {
+  const currentJobs = readJobs(args.current);
+  const baselineJobs = args.baseline ? readJobs(args.baseline) : [];
+  const runnerRates = args.rates ? readRates(args.rates) : {};
+  const excludePatterns = parseList(args.exclude);
+  const current = analyzeJobs(currentJobs, { rateOverrides: runnerRates, excludePatterns });
+  const baseline = analyzeJobs(baselineJobs, { rateOverrides: runnerRates, excludePatterns });
+
+  return {
+    current,
+    baseline,
+    diff: diffSummaries(current, baseline)
+  };
+}
+
+function readRates(filePath) {
+  const content = readFileSync(filePath, "utf8");
+  if (content.trim() === "") {
+    throw new Error("runner-rates must be a valid JSON object: file is empty.");
+  }
+
+  return parseJsonObject(content, {}, "runner-rates");
+}
+
+function evaluateCliThresholds(args, analysis) {
+  const thresholdResult = evaluateThresholds(analysis.diff, {
+    maxIncreasePercent: asNonNegativeNumber(args["fail-on-increase-percent"], "fail-on-increase-percent"),
+    maxIncreaseUsd: asNonNegativeNumber(args["fail-on-increase-usd"], "fail-on-increase-usd"),
+    maxTotalUsd: asNonNegativeNumber(args["fail-on-total-usd"], "fail-on-total-usd")
+  });
+  const currentUnknownJobs = analysis.current.jobs.filter((job) => job.rate === null);
+  const currentAmbiguousRateJobs = analysis.current.jobs.filter((job) => job.rateWarning);
+
+  applyUnknownRunnerGate({ args, thresholdResult, currentUnknownJobs });
+  applyAmbiguousRunnerGate({ args, thresholdResult, currentAmbiguousRateJobs });
+
+  return thresholdResult;
+}
+
+function collectRunnerRateWarnings(analysis) {
+  const current = analysis.current;
+  const baseline = analysis.baseline;
+  const currentUnknownJobs = current.jobs.filter((job) => job.rate === null);
+  const baselineUnknownJobs = baseline.jobs.filter((job) => job.rate === null);
+  const currentAmbiguousRateJobs = current.jobs.filter((job) => job.rateWarning);
+  const baselineAmbiguousRateJobs = baseline.jobs.filter((job) => job.rateWarning);
+
+  return {
+    unknownJobs: [
+      ...withRunLabel(currentUnknownJobs, "current"),
+      ...withRunLabel(baselineUnknownJobs, "baseline")
+    ],
+    ambiguousRateJobs: [
+      ...withRunLabel(currentAmbiguousRateJobs, "current"),
+      ...withRunLabel(baselineAmbiguousRateJobs, "baseline")
+    ]
+  };
+}
+
+function applyUnknownRunnerGate({ args, thresholdResult, currentUnknownJobs }) {
+  if (args["fail-on-unknown-runner"] && currentUnknownJobs.length > 0) {
+    thresholdResult.conclusion = "fail";
+    thresholdResult.failures.push(`${currentUnknownJobs.length} current job(s) used unknown runner rates.`);
+  }
+}
+
+function applyAmbiguousRunnerGate({ args, thresholdResult, currentAmbiguousRateJobs }) {
+  if (args["fail-on-ambiguous-runner-rate"] && currentAmbiguousRateJobs.length > 0) {
+    thresholdResult.conclusion = "fail";
+    thresholdResult.failures.push(`${currentAmbiguousRateJobs.length} current job(s) used ambiguous runner rates.`);
+  }
+}
+
+function renderCliReport({ args, analysis, thresholdResult, runnerRateWarnings }) {
+  return renderReport({
+    diff: analysis.diff,
+    currentRun: { id: "local-current", run_number: "local" },
+    baselineRun: args.baseline ? { id: "local-baseline", run_number: "local" } : null,
+    thresholdResult,
+    unknownJobs: runnerRateWarnings.unknownJobs,
+    ambiguousRateJobs: runnerRateWarnings.ambiguousRateJobs
+  });
+}
+
+function readJobs(filePath) {
+  const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+  if (Array.isArray(parsed)) {
+    return validateJobs(filePath, parsed);
+  }
+
+  if (parsed && !Array.isArray(parsed) && typeof parsed === "object" && Array.isArray(parsed.jobs)) {
+    return validateJobs(filePath, parsed.jobs);
+  }
+
+  throw new Error(`Expected ${filePath} to contain an array or an object with a jobs array.`);
+}
+
+function validateJobs(filePath, jobs) {
+  for (const [index, job] of jobs.entries()) {
+    if (!job || Array.isArray(job) || typeof job !== "object") {
+      throw new Error(`Expected ${filePath} jobs[${index}] to be an object.`);
+    }
+  }
+
+  return jobs;
+}
+
+function withRunLabel(jobs, runLabel) {
+  return jobs.map((job) => ({ ...job, runLabel }));
+}
+
+function parseArgs(argv) {
+  const parsed = {};
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const option = parseOption(argv, index);
+    parsed[option.key] = option.value;
+    index += option.consumedValue ? 1 : 0;
+  }
+
+  return parsed;
+}
+
+function parseOption(argv, index) {
+  const option = parseOptionToken(argv[index]);
+
+  const key = option.key;
+  if (key === "help") {
+    assertNoInlineValue(option);
+    return { key, value: true, consumedValue: false };
+  }
+
+  if (BOOLEAN_OPTIONS.has(key)) {
+    if (option.hasInlineValue) {
+      return { key, value: parseBoolean(inlineOptionValue(option)), consumedValue: false };
+    }
+
+    return { key, value: true, consumedValue: false };
+  }
+
+  assertValueOption(key);
+
+  return option.hasInlineValue
+    ? { key, value: inlineOptionValue(option), consumedValue: false }
+    : { key, value: readOptionValue(argv, index, key), consumedValue: true };
+}
+
+function parseOptionToken(arg) {
+  assertOption(arg);
+  const body = arg.slice(2);
+  const separatorIndex = body.indexOf("=");
+
+  return separatorIndex === -1
+    ? { key: body, hasInlineValue: false }
+    : { key: body.slice(0, separatorIndex), value: body.slice(separatorIndex + 1), hasInlineValue: true };
+}
+
+function assertNoInlineValue(option) {
+  if (option.hasInlineValue) {
+    throw new Error(`--${option.key} does not accept a value.`);
+  }
+}
+
+function inlineOptionValue(option) {
+  assertNonEmptyOptionValue(option.key, option.value);
+  return option.value;
+}
+
+function assertNonEmptyOptionValue(key, value) {
+  if (value === "") {
+    throw new Error(`--${key} requires a value.`);
+  }
+}
+
+function assertOption(arg) {
+  if (!arg.startsWith("--")) {
+    throw new Error(`Unexpected argument: ${arg}`);
+  }
+}
+
+function assertValueOption(key) {
+  if (!VALUE_OPTIONS.has(key)) {
+    throw new Error(`Unknown option: --${key}`);
+  }
+}
+
+function readOptionValue(argv, index, key) {
+  const value = argv[index + 1];
+  if (value === undefined || value === "" || value.startsWith("--")) {
+    throw new Error(`--${key} requires a value.`);
+  }
+
+  return value;
+}
+
+function asNumber(value) {
+  if (value === undefined || value === "") {
+    return undefined;
+  }
+
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`Expected a number, got ${value}`);
+  }
+
+  return parsed;
+}
+
+function asNonNegativeNumber(value, name) {
+  if (typeof value === "string" && value.trim() === "") {
+    throw new Error(`--${name} must be a non-negative number.`);
+  }
+
+  const parsed = asNumber(value);
+  if (parsed !== undefined && parsed < 0) {
+    throw new Error(`--${name} must be a non-negative number.`);
+  }
+
+  return parsed;
+}
+
+function printHelp() {
+  process.stdout.write(`ci-cost-diff
+
+Usage:
+  ci-cost-diff --current current-jobs.json [--baseline baseline-jobs.json]
+
+Options:
+  --help                          Show this help message.
+  --current FILE                    GitHub jobs JSON for the current run.
+  --baseline FILE                   GitHub jobs JSON for the baseline run.
+  --rates FILE                      JSON object with runner rate overrides.
+  --exclude PATTERN[,PATTERN]       Job name patterns to exclude.
+  --fail-on-unknown-runner          Exit 1 if a current job has an unknown runner rate.
+  --fail-on-ambiguous-runner-rate   Exit 1 if a current job used an ambiguous runner rate.
+                                      Boolean flags also accept --flag=true|false.
+  --fail-on-increase-percent N      Exit 1 if cost delta is above N percent.
+  --fail-on-increase-usd N          Exit 1 if cost delta is above N USD.
+  --fail-on-total-usd N             Exit 1 if current cost is above N USD.
+`);
+}

package/docs/ARCHITECTURE.md

@@ -0,0 +1,81 @@
+# Architecture
+
+CI Cost Diff is split into a small calculation core and thin adapters around it.
+
+```mermaid
+flowchart TD
+  A["GitHub Action entrypoint"] --> B["GitHub API adapter"]
+  B --> C["Workflow run jobs"]
+  C --> D["Cost engine"]
+  E["Local CLI"] --> D
+  D --> F["Diff engine"]
+  F --> G["Markdown report"]
+  G --> H["Step summary"]
+  G --> I["Pull request comment"]
+  F --> J["Budget thresholds"]
+```
+
+## Modules
+
+| Path | Responsibility |
+| --- | --- |
+| `src/action.js` | GitHub Action entrypoint, input parsing, run lookup, outputs, comments, failure handling. |
+| `src/github.js` | Minimal GitHub REST API client for workflow runs, jobs, and issue comments. |
+| `src/cost.js` | Duration rounding, job analysis, run summaries, cost diffs, budget threshold checks. |
+| `src/rates.js` | Default GitHub-hosted runner rates, runner SKU inference, custom rate overrides. |
+| `src/report.js` | Markdown report rendering and PR comment marker. |
+| `src/inputs.js` | Dependency-free GitHub Action input parsing helpers. |
+| `bin/ci-cost-diff.js` | Local CLI for comparing saved jobs JSON files. |
+
+## Packaging And Release
+
+The GitHub Action runs checked-in source directly through `action.yml` with `runs.using: node24` and `runs.main: src/action.js`; there is no build or bundled artifact. Package verification asserts the npm tarball contents, CLI executable mode, package metadata, lockfile metadata, action metadata, and release workflow guardrails before publishing.
+
+The release workflow publishes from a checked-out tag with npm Trusted Publishing. It uses a GitHub-hosted runner, `permissions: id-token: write`, Node `24`, `package-manager-cache: false`, and `npm publish --provenance --ignore-scripts`. Once the npm package has a trusted publisher configured for `HupBaHa/cost-diff` and workflow `release.yml`, the workflow does not need `NPM_TOKEN` or another long-lived npm API key.
+
+## Baseline Selection
+
+The action:
+
+1. Reads the current workflow run id from `run-id` or `GITHUB_RUN_ID`.
+2. Fetches the current run to discover its workflow id.
+3. Chooses the baseline branch from `baseline-branch`, pull request base branch, repository default branch, or current run branch.
+4. Finds the latest older successful workflow run for the same workflow on the baseline branch, paging past current or newer runs until `lookback-runs` is exhausted, GitHub returns the final page, or GitHub's documented 1,000-result limit for filtered workflow-run searches is reached.
+5. Fetches all job pages with `filter=all` by default so old rerun attempts are included.
+6. Compares jobs from the current run with jobs from that baseline run.
+
+## Job Matching
+
+Jobs are aggregated by exact GitHub job name. This works well for matrix jobs because GitHub expands matrix values into the visible job name, for example `test (node 22, ubuntu-latest)`.
+
+## Failure Model
+
+The action fails only when configured budget thresholds are exceeded, `fail-on-unknown-runner` is enabled and the current run contains unknown runner rates, or `fail-on-ambiguous-runner-rate` is enabled and the current run contains ambiguous standard-rate fallbacks. Otherwise, unknown runners are shown in the report and counted as `$0.00`.
+
+Pull request comments are best-effort. Update mode scopes comments with a collision-resistant marker, updates the newest same-scope comment from the authenticated token user, and deletes older duplicates. When token identity cannot be resolved, same-scope GitHub App marker comments are left unchanged instead of duplicated. When GitHub exposes a read-only token for fork pull requests, the action skips the comment and still writes the report to the step summary.
+
+## Design Choices
+
+- Dependency-free runtime keeps the action easy to audit and avoids supply-chain overhead.
+- Source files run directly under the GitHub Action Node 24 runtime; there is no bundling step.
+- The cost engine is pure JavaScript and testable without GitHub credentials.
+- GitHub API access is limited to the data needed for reporting.
+- GitHub API responses are validated against the expected REST shapes so malformed successful responses fail closed instead of undercounting.
+- GitHub API path segments are encoded, and numeric path parameters such as run ids, issue numbers, and comment ids are validated before requests are built.
+- GitHub pagination follows final pages and has a high safety guard to avoid malformed endless full-page responses. Baseline workflow-run lookup is capped at GitHub's documented filtered-search limit.
+- Server-provided retry waits from `Retry-After` and `x-ratelimit-reset` are honored up to a bounded maximum; fallback exponential retry delays are also capped.
+- The GitHub API base URL comes from `GITHUB_API_URL`, which keeps GitHub Enterprise Server deployments possible.
+- `current-job-id` can receive `${{ job.check_run_id }}` from the workflow to exclude the reporting job; the action matches it against each job's `check_run_url`. On GitHub Enterprise Server, users may need `exclude-jobs` for custom reporting job names.
+
+## Limitations
+
+- The action estimates list-price compute cost, not actual account billing.
+- Report field values and the final report are truncated for comment reliability, so extremely long job names or labels may be shortened in Markdown output.
+- Larger runner labels are often custom and may require `runner-rates`.
+- Custom-looking runner labels can be priced with a standard default unless `runner-rates` overrides are provided.
+- Generic GPU labels such as `linux` plus `gpu` are not enough to infer a GitHub-hosted GPU runner because GitHub also supports `gpu` as a custom self-hosted label.
+- Self-hosted runners created without default labels cannot be identified from generic OS-plus-architecture labels alone and are reported as unknown unless you provide a specific override.
+- Baseline lookup cannot inspect beyond GitHub's 1,000-result cap for filtered workflow-run searches.
+- A workflow must run on the baseline branch for a useful comparison.
+- The reporting job should depend on the jobs being measured.
+- GitHub does not provide an atomic issue-comment upsert, so concurrent first writers can briefly create duplicate comments before a cleanup pass removes older same-scope duplicates.

package/docs/RATE_MODEL.md

@@ -0,0 +1,103 @@
+# Rate Model
+
+CI Cost Diff estimates GitHub Actions compute cost from workflow job data.
+
+## Formula
+
+For each completed job:
+
+```text
+rounded_minutes = max(1, ceil((completed_at - started_at) / 60 seconds))
+job_cost = rounded_minutes * runner_rate_usd_per_minute
+```
+
+The total run cost is the sum of all analyzed jobs. Jobs with missing, invalid, or negative time intervals are skipped; valid completed jobs are rounded up to at least one billable minute.
+
+Percentage increases are reported as `n/a` when the baseline cost is zero. If `fail-on-increase-percent` is configured, any nonzero current cost fails against a zero-cost baseline. Budget thresholds must be finite and non-negative, and comparisons tolerate insignificant floating-point artifacts from decimal rates. Non-finite threshold inputs or derived budget values fail closed instead of letting budget gates pass silently.
+
+## Default Rates
+
+Default rates are based on GitHub Actions runner pricing from GitHub Docs, checked on 2026-06-07.
+
+| SKU | Rate USD/min |
+| --- | ---: |
+| `actions_linux_slim` | 0.002 |
+| `actions_linux` | 0.006 |
+| `actions_linux_arm` | 0.005 |
+| `actions_windows` | 0.010 |
+| `actions_windows_arm` | 0.010 |
+| `actions_macos` | 0.062 |
+| `linux_2_core_advanced` | 0.006 |
+| `linux_4_core` | 0.012 |
+| `linux_8_core` | 0.022 |
+| `linux_16_core` | 0.042 |
+| `linux_32_core` | 0.082 |
+| `linux_64_core` | 0.162 |
+| `linux_96_core` | 0.252 |
+| `windows_4_core` | 0.022 |
+| `windows_8_core` | 0.042 |
+| `windows_16_core` | 0.082 |
+| `windows_32_core` | 0.162 |
+| `windows_64_core` | 0.322 |
+| `windows_96_core` | 0.552 |
+| `macos_l` | 0.077 |
+| `linux_2_core_arm` | 0.005 |
+| `linux_4_core_arm` | 0.008 |
+| `linux_8_core_arm` | 0.014 |
+| `linux_16_core_arm` | 0.026 |
+| `linux_32_core_arm` | 0.050 |
+| `linux_64_core_arm` | 0.098 |
+| `windows_2_core_arm` | 0.008 |
+| `windows_4_core_arm` | 0.014 |
+| `windows_8_core_arm` | 0.026 |
+| `windows_16_core_arm` | 0.050 |
+| `windows_32_core_arm` | 0.098 |
+| `windows_64_core_arm` | 0.194 |
+| `macos_xl` | 0.102 |
+| `linux_4_core_gpu` | 0.052 |
+| `windows_4_core_gpu` | 0.102 |
+
+Sources:
+
+- GitHub Docs: https://docs.github.com/en/billing/reference/actions-runner-pricing
+- GitHub Docs: https://docs.github.com/en/billing/concepts/product-billing/github-actions
+
+GitHub can change list prices or add runner SKUs. When default rates or SKU inference change, update `src/rates.js`, this table and checked date, and the rate tests together. Use `runner-rates` overrides for private pricing, internal showback rates, or runner labels that GitHub does not expose as a known billing SKU.
+
+## What Is Not Modeled
+
+The action does not model:
+
+- Included monthly minutes by account plan.
+- Public-repository standard-runner free usage.
+- GitHub Pages or Dependabot free usage.
+- Artifact, cache, or package storage billing.
+- Private pricing, enterprise agreements, or discounts.
+- Self-hosted runner infrastructure cost.
+
+Self-hosted jobs are treated as `$0.00` because GitHub does not bill self-hosted runner minutes. You can still assign a rate with an exact self-hosted label, runner name, or runner group override if you want internal showback; broad class keys such as `linux` do not price self-hosted jobs. GitHub lets self-hosted runners omit default labels such as `self-hosted`, so bare generic OS labels such as `linux`, `windows`, or `macos`, generic OS-plus-architecture labels like `linux` and `x64`, `linux` and `arm`, or `windows` and `arm`, combined non-official ARM aliases such as `linux-arm`, `ubuntu-arm`, or `windows-arm`, actions-prefixed hosted-looking aliases such as `actions-ubuntu-arm`, combined OS-plus-GPU labels such as `linux-gpu`, `gpu-linux`, or `ubuntu-gpu`, and non-official Ubuntu-looking labels such as `ubuntu-cache` are treated as unknown unless a more specific override is provided. Split standard labels plus architecture labels, such as `ubuntu-latest` and `arm64`, are also treated as unknown; use official hosted ARM labels such as `ubuntu-24.04-arm` and `ubuntu-22.04-arm`. Split standard labels plus GPU labels, such as `ubuntu-latest` and `gpu`, are treated as unknown because `gpu` can be a custom self-hosted runner label. Generic OS-plus-GPU labels such as `linux` and `gpu` are treated as unknown for the same reason.
+
+## Rerun Attempts
+
+The GitHub jobs API defaults to the latest attempt for a workflow run. CI Cost Diff uses `filter=all` by default so old rerun attempts are included in the estimate. Set `job-filter: latest` if you only want to compare the latest attempt.
+
+## Larger Runners
+
+Known standard and larger-runner billing SKU labels, official workflow labels such as `ubuntu-slim`, `macos-26`, `windows-2025-vs2026`, `ubuntu-24.04-16core`, `windows-2022-16core`, `macos-15-large`, and `macos-26-xlarge`, runner names, and runner group names are matched by default after normalization. GitHub larger runners commonly use custom labels, and the jobs API does not always expose an unambiguous billing SKU. Exact actions-prefixed billing SKU labels such as `actions-linux-arm` or `actions-linux-slim` are priced, but actions-prefixed hosted-looking aliases such as `actions-ubuntu-arm` are not. Exact GPU billing SKU labels such as `linux-4-core-gpu` and `windows-4-core-gpu` are priced, but generic `linux`/`gpu`, `windows`/`gpu`, `ubuntu-latest`/`gpu`, `linux-gpu`, or `gpu-linux` label combinations require an explicit override. For accurate estimates in those cases, pass explicit overrides:
+
+```yaml
+with:
+  runner-rates: |
+    {
+      "ubuntu-8-core": 0.022,
+      "macos-12-core": 0.077
+    }
+```
+
+Override keys are normalized the same way as runner labels. Exact non-class runner labels, names, groups, and known billing SKUs take precedence over class keys. Class-level keys such as `linux`, `windows`, and `macos` apply only to jobs inferred to that standard GitHub-hosted runner SKU, or to explicit runner names/groups, and do not override exact larger-runner labels or generic OS-plus-architecture/GPU labels.
+
+Generic split labels such as `linux` plus `8-core`, `windows` plus `8-core`, or `macos` plus `xlarge` are reported as ambiguous when they fall back to a standard default rate or broad class override. Add a specific override or use a known larger-runner label to avoid underpricing. Arbitrary `actions-*` custom labels remain distinct from non-`actions-*` labels; only known `actions-linux`, `actions-windows`, or `actions-macos` billing SKU aliases normalize to their SKU forms.
+
+## Unknown Runners
+
+Unknown runners are reported and counted as `$0.00` by default. Enable `fail-on-unknown-runner: true` to make current-run unknown rates block the check; baseline unknowns remain report warnings so they do not hide current cost regressions.

package/examples/baseline-jobs.json

@@ -0,0 +1,22 @@
+{
+  "jobs": [
+    {
+      "id": 201,
+      "name": "unit tests",
+      "labels": ["ubuntu-latest"],
+      "runner_name": "GitHub Actions 1",
+      "started_at": "2026-05-10T10:00:00Z",
+      "completed_at": "2026-05-10T10:01:40Z",
+      "conclusion": "success"
+    },
+    {
+      "id": 202,
+      "name": "browser tests",
+      "labels": ["windows-latest"],
+      "runner_name": "GitHub Actions 2",
+      "started_at": "2026-05-10T10:00:00Z",
+      "completed_at": "2026-05-10T10:03:20Z",
+      "conclusion": "success"
+    }
+  ]
+}

package/examples/current-jobs.json

@@ -0,0 +1,22 @@
+{
+  "jobs": [
+    {
+      "id": 101,
+      "name": "unit tests",
+      "labels": ["ubuntu-latest"],
+      "runner_name": "GitHub Actions 1",
+      "started_at": "2026-05-11T10:00:00Z",
+      "completed_at": "2026-05-11T10:02:05Z",
+      "conclusion": "success"
+    },
+    {
+      "id": 102,
+      "name": "browser tests",
+      "labels": ["windows-latest"],
+      "runner_name": "GitHub Actions 2",
+      "started_at": "2026-05-11T10:00:00Z",
+      "completed_at": "2026-05-11T10:04:15Z",
+      "conclusion": "success"
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "ci-cost-diff-action",
+  "version": "0.1.0",
+  "description": "GitHub Action and CLI that estimates GitHub Actions job cost and reports CI cost deltas in pull requests.",
+  "type": "module",
+  "author": "HupBaHa",
+  "homepage": "https://github.com/HupBaHa/cost-diff#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HupBaHa/cost-diff.git"
+  },
+  "bugs": {
+    "url": "https://github.com/HupBaHa/cost-diff/issues"
+  },
+  "bin": {
+    "ci-cost-diff": "bin/ci-cost-diff.js"
+  },
+  "scripts": {
+    "check": "node scripts/check.js",
+    "lint": "eslint . --max-warnings 0",
+    "test": "node --test",
+    "pack:check": "node scripts/pack-check.js",
+    "smoke": "node ./bin/ci-cost-diff.js --current examples/current-jobs.json --baseline examples/baseline-jobs.json",
+    "verify": "node scripts/check.js && npm run lint && npm run test && npm run smoke && npm run pack:check"
+  },
+  "files": [
+    "action.yml",
+    "bin/",
+    "docs/",
+    "examples/",
+    "src/",
+    "CHANGELOG.md",
+    "README.md",
+    "SECURITY.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "github-actions",
+    "finops",
+    "ci",
+    "cost",
+    "pull-request",
+    "devops"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@eslint/js": "^9.39.4",
+    "eslint": "^9.39.4",
+    "globals": "^16.5.0"
+  }
+}