codex-plugin-doctor 1.55.0 → 1.56.0

package/README.md

@@ -480,9 +480,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
-      - uses: Esquetta/CodexPluginDoctor@v1.55.0
+      - uses: Esquetta/CodexPluginDoctor@v1.56.0
         with:
-          version: "1.55.0"
+          version: "1.56.0"
           path: .
           runtime: "true"
           policy: codex-publish

package/dist/core/doctor-size.d.ts

@@ -0,0 +1,16 @@
+export interface DoctorSizeReport {
+    targetPath: string;
+    status: "pass" | "warn" | "fail";
+    totalSize: number;
+    totalSizeHuman: string;
+    fileCount: number;
+    largeFiles: Array<{
+        path: string;
+        size: number;
+        sizeHuman: string;
+    }>;
+    warnings: string[];
+}
+export declare function buildDoctorSize(targetPath: string): Promise<DoctorSizeReport>;
+export declare function renderDoctorSize(report: DoctorSizeReport): string;
+export declare function renderDoctorSizeJson(report: DoctorSizeReport): string;

package/dist/core/doctor-size.js

@@ -0,0 +1,139 @@
+import { readdir, stat } from "node:fs/promises";
+import path from "node:path";
+const skippedDirs = new Set([
+    "node_modules",
+    ".git",
+    ".cache",
+    "dist",
+    "coverage",
+    "__pycache__",
+    ".turbo",
+    ".next",
+    ".nuxt"
+]);
+const largeFileThreshold = 1024 * 1024;
+const packageSizeWarnThreshold = 10 * 1024 * 1024;
+const packageSizeFailThreshold = 50 * 1024 * 1024;
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+    return `${(bytes / 1024 / 1024 / 1024).toFixed(1)} GB`;
+}
+async function scanDirectory(rootPath, currentPath = rootPath) {
+    let totalSize = 0;
+    let fileCount = 0;
+    const largeFiles = [];
+    let entries;
+    try {
+        entries = await readdir(currentPath, { withFileTypes: true });
+    }
+    catch {
+        return { totalSize: 0, fileCount: 0, largeFiles: [] };
+    }
+    for (const entry of entries) {
+        const entryPath = path.join(currentPath, entry.name);
+        if (entry.isDirectory()) {
+            if (skippedDirs.has(entry.name)) {
+                continue;
+            }
+            const subResult = await scanDirectory(rootPath, entryPath);
+            totalSize += subResult.totalSize;
+            fileCount += subResult.fileCount;
+            largeFiles.push(...subResult.largeFiles);
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        let details;
+        try {
+            details = await stat(entryPath);
+        }
+        catch {
+            continue;
+        }
+        totalSize += details.size;
+        fileCount += 1;
+        if (details.size >= largeFileThreshold) {
+            largeFiles.push({
+                path: path.relative(rootPath, entryPath).replace(/\\/g, "/"),
+                size: details.size,
+                sizeHuman: formatSize(details.size)
+            });
+        }
+    }
+    return { totalSize, fileCount, largeFiles };
+}
+export async function buildDoctorSize(targetPath) {
+    const resolvedPath = path.resolve(targetPath);
+    const { totalSize, fileCount, largeFiles } = await scanDirectory(resolvedPath);
+    const warnings = [];
+    let status = "pass";
+    if (totalSize >= packageSizeFailThreshold) {
+        status = "fail";
+        warnings.push(`Package size (${formatSize(totalSize)}) exceeds ${formatSize(packageSizeFailThreshold)}.`);
+    }
+    else if (totalSize >= packageSizeWarnThreshold) {
+        status = "warn";
+        warnings.push(`Package size (${formatSize(totalSize)}) exceeds ${formatSize(packageSizeWarnThreshold)}.`);
+    }
+    if (largeFiles.length > 0) {
+        if (status === "pass")
+            status = "warn";
+        warnings.push(`${largeFiles.length} file(s) exceed ${formatSize(largeFileThreshold)}.`);
+    }
+    largeFiles.sort((a, b) => b.size - a.size);
+    return {
+        targetPath: resolvedPath,
+        status,
+        totalSize,
+        totalSizeHuman: formatSize(totalSize),
+        fileCount,
+        largeFiles: largeFiles.slice(0, 10),
+        warnings
+    };
+}
+export function renderDoctorSize(report) {
+    const lines = [
+        "Codex Plugin Doctor Size Analysis",
+        "=================================",
+        `Path: ${report.targetPath}`,
+        `Status: ${report.status.toUpperCase()}`,
+        `Total size: ${report.totalSizeHuman} (${report.fileCount} files)`,
+        ""
+    ];
+    if (report.warnings.length > 0) {
+        lines.push("Warnings", "--------");
+        for (const warning of report.warnings) {
+            lines.push(`  - ${warning}`);
+        }
+        lines.push("");
+    }
+    if (report.largeFiles.length > 0) {
+        lines.push("Large Files", "-----------");
+        for (const file of report.largeFiles) {
+            lines.push(`  ${file.sizeHuman.padEnd(8)}  ${file.path}`);
+        }
+        lines.push("");
+    }
+    if (report.status === "pass") {
+        lines.push("Package size within acceptable limits.");
+    }
+    return lines.join("\n");
+}
+export function renderDoctorSizeJson(report) {
+    return JSON.stringify({
+        schemaVersion: "1.0.0",
+        targetPath: report.targetPath,
+        status: report.status,
+        totalSize: report.totalSize,
+        totalSizeHuman: report.totalSizeHuman,
+        fileCount: report.fileCount,
+        largeFiles: report.largeFiles,
+        warnings: report.warnings
+    }, null, 2);
+}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import type { CheckOptions, CheckResult } from "./domain/types.js";
+export { buildDoctorSize, renderDoctorSize, renderDoctorSizeJson, type DoctorSizeReport } from "./core/doctor-size.js";
 export { applyDoctorConfig, loadDoctorConfig, type DoctorConfig } from "./core/doctor-config.js";
 export { readRawDoctorConfig, resolveDoctorConfigPath, writeRawDoctorConfig, type LoadedDoctorConfig, type RawDoctorConfig } from "./core/doctor-config-store.js";
 export { classifySuppressionRecord, isValidSuppressionFingerprint, isSuppressionExpired, validateSuppressionRecord, type ClassifiedSuppressionRecord, type InvalidSuppressionRecord, type SuppressionRecordField, type ValidSuppressionRecord } from "./core/suppression-record.js";

package/dist/index.js

@@ -1,4 +1,5 @@
 import { validatePlugin } from "./core/validate-plugin.js";
+export { buildDoctorSize, renderDoctorSize, renderDoctorSizeJson } from "./core/doctor-size.js";
 export { applyDoctorConfig, loadDoctorConfig } from "./core/doctor-config.js";
 export { readRawDoctorConfig, resolveDoctorConfigPath, writeRawDoctorConfig } from "./core/doctor-config-store.js";
 export { classifySuppressionRecord, isValidSuppressionFingerprint, isSuppressionExpired, validateSuppressionRecord } from "./core/suppression-record.js";

package/dist/run-cli.js

@@ -34,6 +34,7 @@ import { buildDoctorRiskDiffReport, renderDoctorRiskDiffReport, renderDoctorRisk
 import { buildDoctorInspectorReport, renderDoctorInspectorReport, renderDoctorInspectorReportJson } from "./core/inspector-bridge.js";
 import { applyFixPlan, buildFixPlan, renderApplyFixResult, renderFixPlanJsonReport, renderFixPlan } from "./core/fix-plan.js";
 import { renderClientDoctor, renderEnvironmentDoctor, renderEnvironmentDoctorJson } from "./core/environment-doctor.js";
+import { buildDoctorSize, renderDoctorSize, renderDoctorSizeJson } from "./core/doctor-size.js";
 import { initCiWorkflow } from "./core/init-ci.js";
 import { watchPlugin } from "./core/watch-plugin.js";
 import { buildDepAudit, renderDepAudit, renderDepAuditJson, renderDepAuditSarif } from "./core/dep-audit.js";
@@ -2101,6 +2102,19 @@ export async function runCli(args, io = defaultIo, options = {}) {
             io.writeStdout(await renderClientDoctor(terminalContext));
             return 0;
         }
+        if (maybePath === "size") {
+            const sizeTarget = remainingArgs[0] && !remainingArgs[0].startsWith("--") ? remainingArgs[0] : ".";
+            const sizeFlags = remainingArgs[0] && remainingArgs[0].startsWith("--")
+                ? remainingArgs
+                : remainingArgs.slice(1);
+            const jsonOutput = sizeFlags.includes("--json");
+            const report = await buildDoctorSize(sizeTarget);
+            const output = jsonOutput
+                ? renderDoctorSizeJson(report)
+                : renderDoctorSize(report);
+            io.writeStdout(output);
+            return report.status === "fail" ? 1 : 0;
+        }
         io.writeStdout(maybePath === "--json"
             ? await renderEnvironmentDoctorJson(terminalContext)
             : await renderEnvironmentDoctor(terminalContext));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-plugin-doctor",
-  "version": "1.55.0",
+  "version": "1.56.0",
   "description": "CLI-first validator for Codex plugins, skills, and MCP package surfaces with runtime MCP protocol validation.",
   "type": "module",
   "main": "./dist/index.js",