@pagepocket/cli 0.10.1 → 0.11.1

package/dist/commands/archive.js

@@ -1,28 +1,71 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 { loadConfiguredPlugins } from "../services/load-configured-plugins.js";
+import { ConfigService } from "../services/config-service.js";
+import { readBuiltinStrategy, listBuiltinStrategyNames } from "../services/strategy/builtin-strategy-registry.js";
+import { StrategyService } from "../services/strategy/strategy-service.js";
+import { normalizeStrategyUnits } from "../services/strategy/strategy-normalize.js";
+import { parsePinnedSpec } from "../services/user-packages/parse-pinned-spec.js";
+import { isUnitLike, resolveUnitConstructor } from "../services/units/unit-validate.js";
+import { UnitStore } from "../services/units/unit-store.js";
+import { uniq } from "../utils/array.js";
+import { withSpinner } from "../utils/with-spinner.js";
+const buildMissingStrategyError = (input) => {
+    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.";
+    return new Error(`Strategy not found: ${input.strategyName}.${suffix}`);
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-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 read_installed_package_version_1 = require("../services/strategy/read-installed-package-version");
-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_store_1 = require("../services/units/unit-store");
-const with_spinner_1 = require("../utils/with-spinner");
-const loadStrategyUnits = async (input) => {
-    const strategyService = new strategy_service_1.StrategyService(input.configService);
-    const unitStore = new unit_store_1.UnitStore(input.configService);
+const resolveStrategy = (input) => {
+    const installedNames = input.strategyService.listInstalledStrategyNames();
+    if (installedNames.includes(input.strategyName)) {
+        return {
+            name: input.strategyName,
+            strategyFile: input.strategyService.readStrategy(input.strategyName),
+            source: "installed"
+        };
+    }
+    const builtin = readBuiltinStrategy(input.strategyName);
+    if (builtin) {
+        return {
+            name: input.strategyName,
+            strategyFile: builtin,
+            source: "builtin"
+        };
+    }
+    throw buildMissingStrategyError({
+        strategyName: input.strategyName,
+        installedNames
+    });
+};
+const assertNoDuplicateUnitIds = (input) => {
+    const seen = new Set();
+    const dup = input.units.find((u) => {
+        if (seen.has(u.id)) {
+            return true;
+        }
+        seen.add(u.id);
+        return false;
+    });
+    if (dup) {
+        throw new Error(`Duplicate unit id detected in strategy ${input.strategyName}: ${dup.id}`);
+    }
+};
+const loadInstalledStrategyUnits = async (input) => {
+    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 pinned = parsePinnedSpec(u.ref);
         const installedVersion = installed[pinned.name];
         if (!installedVersion || installedVersion !== pinned.version) {
             return [
@@ -45,48 +88,100 @@ const loadStrategyUnits = async (input) => {
         throw new Error(`Strategy drift detected (${input.strategyName}). ${details}. ` +
             `Fix: pp strategy update ${input.strategyName} OR pp strategy pin ${input.strategyName}`);
     }
-    const loadedUnits = await Promise.all(normalized.map(async (u) => unitStore.instantiateFromRef(u.ref, u.args)));
-    const seen = new Set();
-    const dup = loadedUnits.find((u) => {
-        if (seen.has(u.id)) {
-            return true;
-        }
-        seen.add(u.id);
-        return false;
+    const units = await Promise.all(normalized.map(async (u) => unitStore.instantiateFromRef(u.ref, u.args)));
+    assertNoDuplicateUnitIds({
+        strategyName: input.strategyName,
+        units
     });
-    if (dup) {
-        throw new Error(`Duplicate unit id detected in strategy ${input.strategyName}: ${dup.id}`);
+    return units;
+};
+const instantiateBuiltinUnit = async (input) => {
+    const req = createRequire(import.meta.url);
+    const pinned = parsePinnedSpec(input.ref);
+    const resolved = req.resolve(pinned.name);
+    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 instance = new ctor(...input.args);
+    if (!isUnitLike(instance)) {
+        throw new Error(`Unit ${pinned.name} exported constructor did not produce a Unit.`);
+    }
+    return instance;
+};
+const loadBuiltinStrategyUnits = async (input) => {
+    const normalized = normalizeStrategyUnits(input.strategyFile);
+    const units = await Promise.all(normalized.map(async (u) => instantiateBuiltinUnit({
+        ref: u.ref,
+        args: u.args
+    })));
+    assertNoDuplicateUnitIds({
+        strategyName: input.strategyName,
+        units
+    });
+    return units;
+};
+const loadStrategyUnits = async (input) => {
+    if (input.strategy.source === "installed") {
+        return loadInstalledStrategyUnits({
+            strategyName: input.strategy.name,
+            configService: input.configService
+        });
     }
-    return loadedUnits;
+    return loadBuiltinStrategyUnits({
+        strategyName: input.strategy.name,
+        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 installedNames = strategyService.listInstalledStrategyNames();
-                if (installedNames.length === 0) {
-                    const v = (0, read_installed_package_version_1.readInstalledPackageVersion)("@pagepocket/builtin-strategy");
-                    await strategyService.addStrategy({
-                        source: `@pagepocket/builtin-strategy@${v}`,
-                        force: false
-                    });
-                }
-                const units = await loadStrategyUnits({
+                const strategy = resolveStrategy({
                     strategyName: name,
+                    strategyService
+                });
+                const units = await loadStrategyUnits({
+                    strategy,
                     configService
                 });
                 const entryTarget = pagepocket;
-                const strategyFile = strategyService.readStrategy(name);
+                const strategyFile = strategy.strategyFile;
                 const captureOptions = strategyFile.pipeline.captureOptions;
                 const effectiveTimeoutMs = typeof timeoutMs === "number" ? timeoutMs : captureOptions?.timeoutMs;
                 const effectiveMaxDurationMs = typeof maxDurationMs === "number" ? maxDurationMs : captureOptions?.maxDurationMs;
@@ -95,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 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;