@pagepocket/cli 0.11.0 → 0.12.0

package/dist/commands/archive.js

@@ -1,61 +1,25 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_module_1 = require("node:module");
-const node_url_1 = require("node:url");
-const core_1 = require("@oclif/core");
-const lib_1 = require("@pagepocket/lib");
-const chalk_1 = __importDefault(require("chalk"));
-const load_configured_plugins_1 = require("../services/load-configured-plugins");
-const config_service_1 = require("../services/config-service");
-const builtin_strategy_registry_1 = require("../services/strategy/builtin-strategy-registry");
-const strategy_service_1 = require("../services/strategy/strategy-service");
-const strategy_normalize_1 = require("../services/strategy/strategy-normalize");
-const parse_pinned_spec_1 = require("../services/user-packages/parse-pinned-spec");
-const unit_validate_1 = require("../services/units/unit-validate");
-const unit_store_1 = require("../services/units/unit-store");
-const array_1 = require("../utils/array");
-const with_spinner_1 = require("../utils/with-spinner");
+import { createRequire } from "node:module";
+import { pathToFileURL } from "node:url";
+import { Args, Command, Flags } from "@oclif/core";
+import { ga, ns, PagePocket } from "@pagepocket/lib";
+import chalk from "chalk";
+import { ConfigService } from "../services/config-service.js";
+import { loadConfiguredPlugins } from "../services/load-configured-plugins.js";
+import { readBuiltinStrategy, listBuiltinStrategyNames } from "../services/strategy/builtin-strategy-registry.js";
+import { normalizeStrategyUnits } from "../services/strategy/strategy-normalize.js";
+import { StrategyService } from "../services/strategy/strategy-service.js";
+import { UnitStore } from "../services/units/unit-store.js";
+import { isUnitLike, resolveUnitConstructor } from "../services/units/unit-validate.js";
+import { parsePinnedSpec } from "../services/user-packages/parse-pinned-spec.js";
+import { uniq } from "../utils/array.js";
+import { withSpinner } from "../utils/with-spinner.js";
 const buildMissingStrategyError = (input) => {
-    const available = (0, array_1.uniq)([...input.installedNames, ...(0, builtin_strategy_registry_1.listBuiltinStrategyNames)()])
+    const available = uniq([...input.installedNames, ...listBuiltinStrategyNames()])
         .filter((name) => name.trim().length > 0)
         .sort((left, right) => left.localeCompare(right));
-    const suffix = available.length > 0 ? ` Available strategies: ${available.join(", ")}` : " No strategies found.";
+    const suffix = available.length > 0
+        ? ` Available strategies: ${available.join(", ")}`
+        : " No strategies found.";
     return new Error(`Strategy not found: ${input.strategyName}.${suffix}`);
 };
 const resolveStrategy = (input) => {
@@ -67,7 +31,7 @@ const resolveStrategy = (input) => {
             source: "installed"
         };
     }
-    const builtin = (0, builtin_strategy_registry_1.readBuiltinStrategy)(input.strategyName);
+    const builtin = readBuiltinStrategy(input.strategyName);
     if (builtin) {
         return {
             name: input.strategyName,
@@ -82,26 +46,26 @@ const resolveStrategy = (input) => {
 };
 const assertNoDuplicateUnitIds = (input) => {
     const seen = new Set();
-    const dup = input.units.find((u) => {
-        if (seen.has(u.id)) {
+    const duplicateUnit = input.units.find((unit) => {
+        if (seen.has(unit.id)) {
             return true;
         }
-        seen.add(u.id);
+        seen.add(unit.id);
         return false;
     });
-    if (dup) {
-        throw new Error(`Duplicate unit id detected in strategy ${input.strategyName}: ${dup.id}`);
+    if (duplicateUnit) {
+        throw new Error(`Duplicate unit id detected in strategy ${input.strategyName}: ${duplicateUnit.id}`);
     }
 };
 const loadInstalledStrategyUnits = async (input) => {
-    const strategyService = new strategy_service_1.StrategyService(input.configService);
-    const unitStore = new unit_store_1.UnitStore(input.configService);
+    const strategyService = new StrategyService(input.configService);
+    const unitStore = new UnitStore(input.configService);
     strategyService.ensureConfigFileExists();
     const strategyFile = strategyService.readStrategy(input.strategyName);
-    const normalized = (0, strategy_normalize_1.normalizeStrategyUnits)(strategyFile);
+    const normalized = normalizeStrategyUnits(strategyFile);
     const installed = unitStore.readInstalledDependencyVersions();
-    const drift = normalized.flatMap((u) => {
-        const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(u.ref);
+    const drift = normalized.flatMap((unit) => {
+        const pinned = parsePinnedSpec(unit.ref);
         const installedVersion = installed[pinned.name];
         if (!installedVersion || installedVersion !== pinned.version) {
             return [
@@ -116,15 +80,15 @@ const loadInstalledStrategyUnits = async (input) => {
     });
     if (drift.length > 0) {
         const details = drift
-            .map((d) => {
-            const installedText = typeof d.installed === "string" ? d.installed : "(not installed)";
-            return `${d.name}: pinned ${d.pinned}, installed ${installedText}`;
+            .map((driftItem) => {
+            const installedText = typeof driftItem.installed === "string" ? driftItem.installed : "(not installed)";
+            return `${driftItem.name}: pinned ${driftItem.pinned}, installed ${installedText}`;
         })
             .join("; ");
         throw new Error(`Strategy drift detected (${input.strategyName}). ${details}. ` +
             `Fix: pp strategy update ${input.strategyName} OR pp strategy pin ${input.strategyName}`);
     }
-    const units = await Promise.all(normalized.map(async (u) => unitStore.instantiateFromRef(u.ref, u.args)));
+    const units = await Promise.all(normalized.map(async (unit) => unitStore.instantiateFromRef(unit.ref, unit.args)));
     assertNoDuplicateUnitIds({
         strategyName: input.strategyName,
         units
@@ -132,26 +96,25 @@ const loadInstalledStrategyUnits = async (input) => {
     return units;
 };
 const instantiateBuiltinUnit = async (input) => {
-    const req = (0, node_module_1.createRequire)(__filename);
-    const pinned = (0, parse_pinned_spec_1.parsePinnedSpec)(input.ref);
+    const req = createRequire(import.meta.url);
+    const pinned = parsePinnedSpec(input.ref);
     const resolved = req.resolve(pinned.name);
-    const mod = (await Promise.resolve(`${(0, node_url_1.pathToFileURL)(resolved).href}`).then(s => __importStar(require(s))));
-    const def = mod.default;
-    if (typeof def !== "function") {
-        throw new Error(`Unit ${pinned.name} must default export a constructor.`);
+    const mod = (await import(pathToFileURL(resolved).href));
+    const ctor = resolveUnitConstructor(mod);
+    if (!ctor) {
+        throw new Error(`Unit ${pinned.name} does not export a Unit constructor.`);
     }
-    const ctor = def;
     const instance = new ctor(...input.args);
-    if (!(0, unit_validate_1.isUnitLike)(instance)) {
-        throw new Error(`Unit ${pinned.name} default export did not construct a Unit.`);
+    if (!isUnitLike(instance)) {
+        throw new Error(`Unit ${pinned.name} exported constructor did not produce a Unit.`);
     }
     return instance;
 };
 const loadBuiltinStrategyUnits = async (input) => {
-    const normalized = (0, strategy_normalize_1.normalizeStrategyUnits)(input.strategyFile);
-    const units = await Promise.all(normalized.map(async (u) => instantiateBuiltinUnit({
-        ref: u.ref,
-        args: u.args
+    const normalized = normalizeStrategyUnits(input.strategyFile);
+    const units = await Promise.all(normalized.map(async (unit) => instantiateBuiltinUnit({
+        ref: unit.ref,
+        args: unit.args
     })));
     assertNoDuplicateUnitIds({
         strategyName: input.strategyName,
@@ -171,19 +134,43 @@ const loadStrategyUnits = async (input) => {
         strategyFile: input.strategy.strategyFile
     });
 };
-class ArchiveCommand extends core_1.Command {
+export default class ArchiveCommand extends Command {
+    static description = "Archive a web page as an offline snapshot.";
+    static args = {
+        url: Args.string({
+            description: "URL to archive",
+            required: true
+        })
+    };
+    static flags = {
+        help: Flags.help({
+            char: "h"
+        }),
+        timeout: Flags.integer({
+            char: "t",
+            description: "Network idle duration in milliseconds before capture stops",
+            required: false
+        }),
+        maxDuration: Flags.integer({
+            description: "Hard max capture duration in milliseconds",
+            required: false
+        }),
+        strategy: Flags.string({
+            description: "Run an installed or built-in strategy (unit pipeline) by name"
+        })
+    };
     async run() {
         const { args, flags } = await this.parse(ArchiveCommand);
         const targetUrl = args.url;
         const timeoutMs = typeof flags.timeout === "number" ? flags.timeout : undefined;
         const maxDurationMs = typeof flags.maxDuration === "number" ? flags.maxDuration : undefined;
         const strategyName = typeof flags.strategy === "string" ? flags.strategy.trim() : undefined;
-        const pagepocket = lib_1.PagePocket.fromURL(targetUrl);
-        const result = await (0, with_spinner_1.withSpinner)(async (spinner) => {
+        const pagepocket = PagePocket.fromURL(targetUrl);
+        const result = await withSpinner(async (spinner) => {
             {
-                const configService = new config_service_1.ConfigService();
+                const configService = new ConfigService();
                 const name = strategyName && strategyName.length > 0 ? strategyName : "default";
-                const strategyService = new strategy_service_1.StrategyService(configService);
+                const strategyService = new StrategyService(configService);
                 strategyService.ensureConfigFileExists();
                 const strategy = resolveStrategy({
                     strategyName: name,
@@ -203,45 +190,20 @@ class ArchiveCommand extends core_1.Command {
                     ...(typeof effectiveMaxDurationMs === "number"
                         ? { maxDurationMs: effectiveMaxDurationMs }
                         : {}),
-                    blacklist: [...lib_1.ga, ...lib_1.ns],
+                    blacklist: [...ga, ...ns],
                     units,
-                    plugins: await (0, load_configured_plugins_1.loadConfiguredPlugins)().catch(() => [])
+                    plugins: await loadConfiguredPlugins().catch(() => [])
                 });
                 return result;
             }
         }, "Freezing page");
-        this.log(chalk_1.default.green("All done! Snapshot created."));
+        this.log(chalk.green("All done! Snapshot created."));
         if (result.kind === "zip") {
-            this.log(`Snapshot saved to ${chalk_1.default.cyan(result.zip.outputPath)}`);
+            this.log(`Snapshot saved to ${chalk.cyan(result.zip.outputPath)}`);
         }
         else if (result.kind === "raw") {
-            this.log(`Snapshot saved to ${chalk_1.default.cyan(result.outputDir)}`);
+            this.log(`Snapshot saved to ${chalk.cyan(result.outputDir)}`);
         }
         process.exit();
     }
 }
-ArchiveCommand.description = "Archive a web page as an offline snapshot.";
-ArchiveCommand.args = {
-    url: core_1.Args.string({
-        description: "URL to archive",
-        required: true
-    })
-};
-ArchiveCommand.flags = {
-    help: core_1.Flags.help({
-        char: "h"
-    }),
-    timeout: core_1.Flags.integer({
-        char: "t",
-        description: "Network idle duration in milliseconds before capture stops",
-        required: false
-    }),
-    maxDuration: core_1.Flags.integer({
-        description: "Hard max capture duration in milliseconds",
-        required: false
-    }),
-    strategy: core_1.Flags.string({
-        description: "Run an installed or built-in strategy (unit pipeline) by name"
-    })
-};
-exports.default = ArchiveCommand;

package/dist/commands/plugin/add.js

@@ -1,17 +1,14 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const chalk_1 = __importDefault(require("chalk"));
-const config_service_1 = require("../../services/config-service");
-const plugin_installer_1 = require("../../services/plugin-installer");
-const plugin_store_1 = require("../../services/plugin-store");
-const parse_plugin_options_1 = require("../../utils/parse-plugin-options");
-const parse_plugin_spec_1 = require("../../utils/parse-plugin-spec");
-const validate_plugin_default_export_1 = require("../../utils/validate-plugin-default-export");
-class PluginAddCommand extends core_1.Command {
+import { Command } from "@oclif/core";
+import chalk from "chalk";
+import { ConfigService } from "../../services/config-service.js";
+import { installPluginPackage } from "../../services/plugin-installer.js";
+import { PluginStore } from "../../services/plugin-store.js";
+import { parsePluginOptions } from "../../utils/parse-plugin-options.js";
+import { parsePluginSpec } from "../../utils/parse-plugin-spec.js";
+import { validatePluginDefaultExport } from "../../utils/validate-plugin-default-export.js";
+export default class PluginAddCommand extends Command {
+    static description = "Install a plugin package, add it to config, and run its optional setup().";
+    static strict = false;
     async run() {
         const [name, ...rest] = this.argv;
         if (!name) {
@@ -21,24 +18,24 @@ class PluginAddCommand extends core_1.Command {
             this.log("Usage: pp plugin add <plugin-name> [--option-* <value> ...] [--option <value> ...]");
             return;
         }
-        const parsedSpec = (0, parse_plugin_spec_1.parsePluginSpec)(name);
-        const configService = new config_service_1.ConfigService();
-        const store = new plugin_store_1.PluginStore(configService);
+        const parsedSpec = parsePluginSpec(name);
+        const configService = new ConfigService();
+        const store = new PluginStore(configService);
         configService.ensureConfigFileExists();
         const config = configService.readConfigOrDefault();
         if (store.hasPlugin(config, parsedSpec.name)) {
-            this.log(chalk_1.default.gray(`Plugin already exists in config: ${parsedSpec.name}`));
+            this.log(chalk.gray(`Plugin already exists in config: ${parsedSpec.name}`));
             return;
         }
-        const parsed = (0, parse_plugin_options_1.parsePluginOptions)(rest);
+        const parsed = parsePluginOptions(rest);
         const entry = parsed.kind === "none"
             ? parsedSpec.name
             : parsed.kind === "array"
                 ? { name: parsedSpec.name, spec: parsedSpec.spec, options: parsed.value }
                 : { name: parsedSpec.name, spec: parsedSpec.spec, options: parsed.value };
-        (0, plugin_installer_1.installPluginPackage)(store, { packageName: parsedSpec.spec });
+        installPluginPackage(store, { packageName: parsedSpec.spec });
         const mod = await store.importPluginModule(parsedSpec.name);
-        const validation = (0, validate_plugin_default_export_1.validatePluginDefaultExport)({
+        const validation = validatePluginDefaultExport({
             pluginName: parsedSpec.name,
             moduleExports: mod,
             options: parsed.kind === "none" ? undefined : parsed.value
@@ -49,9 +46,6 @@ class PluginAddCommand extends core_1.Command {
         const nextConfig = store.addPluginToConfig(config, entry);
         configService.writeConfig(nextConfig);
         await store.runOptionalSetup(parsedSpec.name);
-        this.log(chalk_1.default.green(`Added plugin: ${parsedSpec.name}`));
+        this.log(chalk.green(`Added plugin: ${parsedSpec.name}`));
     }
 }
-PluginAddCommand.description = "Install a plugin package, add it to config, and run its optional setup().";
-PluginAddCommand.strict = false;
-exports.default = PluginAddCommand;

package/dist/commands/plugin/doctor.js

@@ -1,13 +1,8 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const chalk_1 = __importDefault(require("chalk"));
-const config_service_1 = require("../../services/config-service");
-const plugin_store_1 = require("../../services/plugin-store");
-const parse_plugin_spec_1 = require("../../utils/parse-plugin-spec");
+import { Args, Command } from "@oclif/core";
+import chalk from "chalk";
+import { ConfigService } from "../../services/config-service.js";
+import { PluginStore, normalizePluginConfigEntry } from "../../services/plugin-store.js";
+import { parsePluginSpec } from "../../utils/parse-plugin-spec.js";
 /**
  * Validate one configured plugin can be loaded and instantiated.
  *
@@ -41,16 +36,23 @@ const runDoctorCheck = async (store, spec) => {
         };
     }
 };
-class PluginDoctorCommand extends core_1.Command {
+export default class PluginDoctorCommand extends Command {
+    static description = "Validate configured plugins are installed and loadable.";
+    static args = {
+        name: Args.string({
+            description: "npm package name (optional; if omitted checks all configured plugins)",
+            required: false
+        })
+    };
     async run() {
         const { args } = await this.parse(PluginDoctorCommand);
-        const configService = new config_service_1.ConfigService();
-        const store = new plugin_store_1.PluginStore(configService);
+        const configService = new ConfigService();
+        const store = new PluginStore(configService);
         configService.ensureConfigFileExists();
         const config = store.readConfig();
-        const targetName = args.name ? (0, parse_plugin_spec_1.parsePluginSpec)(args.name).name : undefined;
+        const targetName = args.name ? parsePluginSpec(args.name).name : undefined;
         const configured = config.plugins
-            .map((entry) => (0, plugin_store_1.normalizePluginConfigEntry)(entry))
+            .map((entry) => normalizePluginConfigEntry(entry))
             .filter((entry) => {
             if (!targetName) {
                 return true;
@@ -59,33 +61,25 @@ class PluginDoctorCommand extends core_1.Command {
         });
         if (configured.length === 0) {
             if (targetName) {
-                this.log(chalk_1.default.gray(`Plugin not found in config: ${targetName}`));
+                this.log(chalk.gray(`Plugin not found in config: ${targetName}`));
                 return;
             }
-            this.log(chalk_1.default.gray("No plugins configured."));
+            this.log(chalk.gray("No plugins configured."));
             return;
         }
         const checks = await Promise.all(configured.map((entry) => runDoctorCheck(store, entry)));
         const failed = checks.filter((item) => !item.installed || !item.loadable);
         checks.forEach((item) => {
             if (item.installed && item.loadable) {
-                this.log(chalk_1.default.green(`[OK] ${item.plugin}`));
+                this.log(chalk.green(`[OK] ${item.plugin}`));
                 return;
             }
-            this.log(chalk_1.default.red(`[FAIL] ${item.plugin}: ${item.error ?? "unknown error"}`));
+            this.log(chalk.red(`[FAIL] ${item.plugin}: ${item.error ?? "unknown error"}`));
         });
         if (failed.length === 0) {
-            this.log(chalk_1.default.green("Plugin doctor checks passed."));
+            this.log(chalk.green("Plugin doctor checks passed."));
             return;
         }
         throw new Error(`${failed.length} plugin(s) failed doctor checks.`);
     }
 }
-PluginDoctorCommand.description = "Validate configured plugins are installed and loadable.";
-PluginDoctorCommand.args = {
-    name: core_1.Args.string({
-        description: "npm package name (optional; if omitted checks all configured plugins)",
-        required: false
-    })
-};
-exports.default = PluginDoctorCommand;

package/dist/commands/plugin/ls.js

@@ -1,21 +1,17 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const chalk_1 = __importDefault(require("chalk"));
-const config_service_1 = require("../../services/config-service");
-const plugin_store_1 = require("../../services/plugin-store");
-class PluginLsCommand extends core_1.Command {
+import { Command } from "@oclif/core";
+import chalk from "chalk";
+import { ConfigService } from "../../services/config-service.js";
+import { PluginStore } from "../../services/plugin-store.js";
+export default class PluginLsCommand extends Command {
+    static description = "List configured plugins.";
     async run() {
-        const configService = new config_service_1.ConfigService();
-        const store = new plugin_store_1.PluginStore(configService);
+        const configService = new ConfigService();
+        const store = new PluginStore(configService);
         configService.ensureConfigFileExists();
         const config = configService.readConfigOrDefault();
         const entries = config.plugins;
         if (entries.length === 0) {
-            this.log(chalk_1.default.gray("No plugins configured."));
+            this.log(chalk.gray("No plugins configured."));
             return;
         }
         entries
@@ -28,18 +24,16 @@ class PluginLsCommand extends core_1.Command {
                     : undefined;
             const meta = store.readInstalledPackageMeta(name);
             if (!meta) {
-                const specText = configuredSpec ? chalk_1.default.gray(`(configured: ${configuredSpec})`) : "";
-                return `${chalk_1.default.yellow(name)} ${chalk_1.default.gray("(not installed)")} ${specText}`.trim();
+                const specText = configuredSpec ? chalk.gray(`(configured: ${configuredSpec})`) : "";
+                return `${chalk.yellow(name)} ${chalk.gray("(not installed)")} ${specText}`.trim();
             }
-            const specText = configuredSpec ? chalk_1.default.gray(`(configured: ${configuredSpec})`) : "";
+            const specText = configuredSpec ? chalk.gray(`(configured: ${configuredSpec})`) : "";
             const desc = meta.description
-                ? chalk_1.default.gray(meta.description)
-                : chalk_1.default.gray("(no description)");
-            const version = meta.version ? chalk_1.default.cyan(`v${meta.version}`) : chalk_1.default.gray("(no version)");
-            return `${chalk_1.default.green(meta.name)} ${version} ${specText}  ${desc}`.replace(/\s{2,}/g, "  ");
+                ? chalk.gray(meta.description)
+                : chalk.gray("(no description)");
+            const version = meta.version ? chalk.cyan(`v${meta.version}`) : chalk.gray("(no version)");
+            return `${chalk.green(meta.name)} ${version} ${specText}  ${desc}`.replace(/\s{2,}/g, "  ");
         })
             .forEach((line) => this.log(line));
     }
 }
-PluginLsCommand.description = "List configured plugins.";
-exports.default = PluginLsCommand;

package/dist/commands/plugin/prune.js

@@ -1,13 +1,8 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const chalk_1 = __importDefault(require("chalk"));
-const config_service_1 = require("../../services/config-service");
-const plugin_installer_1 = require("../../services/plugin-installer");
-const plugin_store_1 = require("../../services/plugin-store");
+import { Command } from "@oclif/core";
+import chalk from "chalk";
+import { ConfigService } from "../../services/config-service.js";
+import { uninstallPluginPackage } from "../../services/plugin-installer.js";
+import { PluginStore, normalizePluginConfigEntry } from "../../services/plugin-store.js";
 /**
  * Get configured plugin names from config.
  *
@@ -17,27 +12,26 @@ const plugin_store_1 = require("../../services/plugin-store");
 const getConfiguredPluginNames = (store) => {
     const config = store.readConfig();
     const names = config.plugins
-        .map((entry) => (0, plugin_store_1.normalizePluginConfigEntry)(entry).name)
+        .map((entry) => normalizePluginConfigEntry(entry).name)
         .filter((name) => name.trim().length > 0);
     return new Set(names);
 };
-class PluginPruneCommand extends core_1.Command {
+export default class PluginPruneCommand extends Command {
+    static description = "Uninstall plugin packages that are not referenced by config.";
     async run() {
-        const configService = new config_service_1.ConfigService();
-        const store = new plugin_store_1.PluginStore(configService);
+        const configService = new ConfigService();
+        const store = new PluginStore(configService);
         configService.ensureConfigFileExists();
         const configured = getConfiguredPluginNames(store);
         const installed = store.readInstalledDependencyNames();
         const orphans = installed.filter((name) => !configured.has(name));
         if (orphans.length === 0) {
-            this.log(chalk_1.default.gray("No orphan plugin packages found."));
+            this.log(chalk.gray("No orphan plugin packages found."));
             return;
         }
         orphans.forEach((name) => {
-            (0, plugin_installer_1.uninstallPluginPackage)(store, { packageName: name });
-            this.log(chalk_1.default.green(`Pruned plugin package: ${name}`));
+            uninstallPluginPackage(store, { packageName: name });
+            this.log(chalk.green(`Pruned plugin package: ${name}`));
         });
     }
 }
-PluginPruneCommand.description = "Uninstall plugin packages that are not referenced by config.";
-exports.default = PluginPruneCommand;

package/dist/commands/plugin/remove.js

@@ -1,34 +1,28 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const chalk_1 = __importDefault(require("chalk"));
-const config_service_1 = require("../../services/config-service");
-const plugin_store_1 = require("../../services/plugin-store");
-class PluginRemoveCommand extends core_1.Command {
+import { Args, Command } from "@oclif/core";
+import chalk from "chalk";
+import { ConfigService } from "../../services/config-service.js";
+import { PluginStore } from "../../services/plugin-store.js";
+export default class PluginRemoveCommand extends Command {
+    static description = "Remove a plugin from config (does not uninstall).";
+    static args = {
+        name: Args.string({
+            description: "npm package name",
+            required: true
+        })
+    };
     async run() {
         const { args } = await this.parse(PluginRemoveCommand);
         const name = args.name;
-        const configService = new config_service_1.ConfigService();
-        const store = new plugin_store_1.PluginStore(configService);
+        const configService = new ConfigService();
+        const store = new PluginStore(configService);
         configService.ensureConfigFileExists();
         const config = configService.readConfigOrDefault();
         const out = store.removePluginFromConfig(config, name);
         if (!out.removed) {
-            this.log(chalk_1.default.gray(`Plugin not found in config: ${name}`));
+            this.log(chalk.gray(`Plugin not found in config: ${name}`));
             return;
         }
         configService.writeConfig(out.config);
-        this.log(chalk_1.default.green(`Removed from config: ${name}`));
+        this.log(chalk.green(`Removed from config: ${name}`));
     }
 }
-PluginRemoveCommand.description = "Remove a plugin from config (does not uninstall).";
-PluginRemoveCommand.args = {
-    name: core_1.Args.string({
-        description: "npm package name",
-        required: true
-    })
-};
-exports.default = PluginRemoveCommand;