@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/commands/plugin/ValidatePlugin.js

@@ -0,0 +1,95 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import figures from 'figures';
+import { useEffect } from 'react';
+import { Box, Text } from '../../ink.js';
+import { errorMessage } from '../../utils/errors.js';
+import { logError } from '../../utils/log.js';
+import { validateManifest } from '../../utils/plugins/validatePlugin.js';
+import { plural } from '../../utils/stringUtils.js';
+export function ValidatePlugin(t0) {
+    const $ = _c(5);
+    const { onComplete, path } = t0;
+    let t1;
+    let t2;
+    if ($[0] !== onComplete || $[1] !== path) {
+        t1 = () => {
+            const runValidation = async function runValidation() {
+                if (!path) {
+                    onComplete("Usage: /plugin validate <path>\n\nValidate a plugin or marketplace manifest file or directory.\n\nExamples:\n  /plugin validate .claude-plugin/plugin.json\n  /plugin validate /path/to/plugin-directory\n  /plugin validate .\n\nWhen given a directory, automatically validates .claude-plugin/marketplace.json\nor .claude-plugin/plugin.json (prefers marketplace if both exist).\n\nOr from the command line:\n  claude plugin validate <path>");
+                    return;
+                }
+                ;
+                try {
+                    const result = await validateManifest(path);
+                    let output = "";
+                    output = output + `Validating ${result.fileType} manifest: ${result.filePath}\n\n`;
+                    output;
+                    if (result.errors.length > 0) {
+                        output = output + `${figures.cross} Found ${result.errors.length} ${plural(result.errors.length, "error")}:\n\n`;
+                        output;
+                        result.errors.forEach(error_0 => {
+                            output = output + `  ${figures.pointer} ${error_0.path}: ${error_0.message}\n`;
+                            output;
+                        });
+                        output = output + "\n";
+                        output;
+                    }
+                    if (result.warnings.length > 0) {
+                        output = output + `${figures.warning} Found ${result.warnings.length} ${plural(result.warnings.length, "warning")}:\n\n`;
+                        output;
+                        result.warnings.forEach(warning => {
+                            output = output + `  ${figures.pointer} ${warning.path}: ${warning.message}\n`;
+                            output;
+                        });
+                        output = output + "\n";
+                        output;
+                    }
+                    if (result.success) {
+                        if (result.warnings.length > 0) {
+                            output = output + `${figures.tick} Validation passed with warnings\n`;
+                            output;
+                        }
+                        else {
+                            output = output + `${figures.tick} Validation passed\n`;
+                            output;
+                        }
+                        process.exitCode = 0;
+                    }
+                    else {
+                        output = output + `${figures.cross} Validation failed\n`;
+                        output;
+                        process.exitCode = 1;
+                    }
+                    onComplete(output);
+                }
+                catch (t3) {
+                    const error = t3;
+                    process.exitCode = 2;
+                    logError(error);
+                    onComplete(`${figures.cross} Unexpected error during validation: ${errorMessage(error)}`);
+                }
+            };
+            runValidation();
+        };
+        t2 = [onComplete, path];
+        $[0] = onComplete;
+        $[1] = path;
+        $[2] = t1;
+        $[3] = t2;
+    }
+    else {
+        t1 = $[2];
+        t2 = $[3];
+    }
+    useEffect(t1, t2);
+    let t3;
+    if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+        t3 = _jsx(Box, { flexDirection: "column", children: _jsx(Text, { children: "Running validation..." }) });
+        $[4] = t3;
+    }
+    else {
+        t3 = $[4];
+    }
+    return t3;
+}

package/dist/src/commands/plugin/index.js

@@ -0,0 +1,10 @@
+const plugin = {
+    type: 'local-jsx',
+    name: 'plugin',
+    aliases: ['plugins', 'marketplace'],
+    description: 'Gestionar complementos de Context Code',
+    immediate: true,
+    load: () => import('./plugin.js')
+};
+export default plugin;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJDb21tYW5kIiwicGx1Z2luIiwidHlwZSIsIm5hbWUiLCJhbGlhc2VzIiwiZGVzY3JpcHRpb24iLCJpbW1lZGlhdGUiLCJsb2FkIl0sInNvdXJjZXMiOlsiaW5kZXgudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgQ29tbWFuZCB9IGZyb20gJy4uLy4uL2NvbW1hbmRzLmpzJ1xuXG5jb25zdCBwbHVnaW4gPSB7XG4gIHR5cGU6ICdsb2NhbC1qc3gnLFxuICBuYW1lOiAncGx1Z2luJyxcbiAgYWxpYXNlczogWydwbHVnaW5zJywgJ21hcmtldHBsYWNlJ10sXG4gIGRlc2NyaXB0aW9uOiAnTWFuYWdlIENsYXVkZSBDb2RlIHBsdWdpbnMnLFxuICBpbW1lZGlhdGU6IHRydWUsXG4gIGxvYWQ6ICgpID0+IGltcG9ydCgnLi9wbHVnaW4uanMnKSxcbn0gc2F0aXNmaWVzIENvbW1hbmRcblxuZXhwb3J0IGRlZmF1bHQgcGx1Z2luXG4iXSwibWFwcGluZ3MiOiJBQUFBLGNBQWNBLE9BQU8sUUFBUSxtQkFBbUI7QUFFaEQsTUFBTUMsTUFBTSxHQUFHO0VBQ2JDLElBQUksRUFBRSxXQUFXO0VBQ2pCQyxJQUFJLEVBQUUsUUFBUTtFQUNkQyxPQUFPLEVBQUUsQ0FBQyxTQUFTLEVBQUUsYUFBYSxDQUFDO0VBQ25DQyxXQUFXLEVBQUUsNEJBQTRCO0VBQ3pDQyxTQUFTLEVBQUUsSUFBSTtFQUNmQyxJQUFJLEVBQUVBLENBQUEsS0FBTSxNQUFNLENBQUMsYUFBYTtBQUNsQyxDQUFDLFdBQVdQLE9BQU87QUFFbkIsZUFBZUMsTUFBTSIsImlnbm9yZUxpc3QiOltdfQ==

package/dist/src/commands/plugin/parseArgs.js

@@ -0,0 +1,71 @@
+export function parsePluginArgs(args) {
+    if (!args) {
+        return { type: 'menu' };
+    }
+    const parts = args.trim().split(/\s+/);
+    const command = parts[0]?.toLowerCase();
+    switch (command) {
+        case 'help':
+        case '--help':
+        case '-h':
+            return { type: 'help' };
+        case 'install':
+        case 'i': {
+            const target = parts[1];
+            if (!target) {
+                return { type: 'install' };
+            }
+            // Check if it's in format plugin@marketplace
+            if (target.includes('@')) {
+                const [plugin, marketplace] = target.split('@');
+                return { type: 'install', plugin, marketplace };
+            }
+            // Check if the target looks like a marketplace (URL or path)
+            const isMarketplace = target.startsWith('http://') ||
+                target.startsWith('https://') ||
+                target.startsWith('file://') ||
+                target.includes('/') ||
+                target.includes('\\');
+            if (isMarketplace) {
+                // This is a marketplace URL/path, no plugin specified
+                return { type: 'install', marketplace: target };
+            }
+            // Otherwise treat it as a plugin name
+            return { type: 'install', plugin: target };
+        }
+        case 'manage':
+            return { type: 'manage' };
+        case 'uninstall':
+            return { type: 'uninstall', plugin: parts[1] };
+        case 'enable':
+            return { type: 'enable', plugin: parts[1] };
+        case 'disable':
+            return { type: 'disable', plugin: parts[1] };
+        case 'validate': {
+            const target = parts.slice(1).join(' ').trim();
+            return { type: 'validate', path: target || undefined };
+        }
+        case 'marketplace':
+        case 'market': {
+            const action = parts[1]?.toLowerCase();
+            const target = parts.slice(2).join(' ');
+            switch (action) {
+                case 'add':
+                    return { type: 'marketplace', action: 'add', target };
+                case 'remove':
+                case 'rm':
+                    return { type: 'marketplace', action: 'remove', target };
+                case 'update':
+                    return { type: 'marketplace', action: 'update', target };
+                case 'list':
+                    return { type: 'marketplace', action: 'list' };
+                default:
+                    // No action specified, show marketplace menu
+                    return { type: 'marketplace' };
+            }
+        }
+        default:
+            // Unknown command, show menu
+            return { type: 'menu' };
+    }
+}

package/dist/src/commands/plugin/plugin.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { PluginSettings } from './PluginSettings.js';
+export async function call(onDone, _context, args) {
+    return _jsx(PluginSettings, { onComplete: onDone, args: args });
+}

package/dist/src/commands/plugin/pluginDetailsHelpers.js

@@ -0,0 +1,89 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import { ConfigurableShortcutHint } from '../../components/ConfigurableShortcutHint.js';
+import { Byline } from '../../components/design-system/Byline.js';
+import { Box, Text } from '../../ink.js';
+/**
+ * Extract GitHub repo info from a plugin's source
+ */
+export function extractGitHubRepo(plugin) {
+    const isGitHub = plugin.entry.source && typeof plugin.entry.source === 'object' && 'source' in plugin.entry.source && plugin.entry.source.source === 'github';
+    if (isGitHub && typeof plugin.entry.source === 'object' && 'repo' in plugin.entry.source) {
+        return plugin.entry.source.repo;
+    }
+    return null;
+}
+/**
+ * Build menu options for plugin details view with scoped installation options
+ */
+export function buildPluginDetailsMenuOptions(hasHomepage, githubRepo) {
+    const options = [{
+            label: 'Install for you (user scope)',
+            action: 'install-user'
+        }, {
+            label: 'Install for all collaborators on this repository (project scope)',
+            action: 'install-project'
+        }, {
+            label: 'Install for you, in this repo only (local scope)',
+            action: 'install-local'
+        }];
+    if (hasHomepage) {
+        options.push({
+            label: 'Open homepage',
+            action: 'homepage'
+        });
+    }
+    if (githubRepo) {
+        options.push({
+            label: 'View on GitHub',
+            action: 'github'
+        });
+    }
+    options.push({
+        label: 'Back to plugin list',
+        action: 'back'
+    });
+    return options;
+}
+/**
+ * Key hint component for plugin selection screens
+ */
+export function PluginSelectionKeyHint(t0) {
+    const $ = _c(7);
+    const { hasSelection } = t0;
+    let t1;
+    if ($[0] !== hasSelection) {
+        t1 = hasSelection && _jsx(ConfigurableShortcutHint, { action: "plugin:install", context: "Plugin", fallback: "i", description: "install", bold: true });
+        $[0] = hasSelection;
+        $[1] = t1;
+    }
+    else {
+        t1 = $[1];
+    }
+    let t2;
+    let t3;
+    let t4;
+    if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+        t2 = _jsx(ConfigurableShortcutHint, { action: "plugin:toggle", context: "Plugin", fallback: "Space", description: "toggle" });
+        t3 = _jsx(ConfigurableShortcutHint, { action: "select:accept", context: "Select", fallback: "Enter", description: "details" });
+        t4 = _jsx(ConfigurableShortcutHint, { action: "confirm:no", context: "Confirmation", fallback: "Esc", description: "volver" });
+        $[2] = t2;
+        $[3] = t3;
+        $[4] = t4;
+    }
+    else {
+        t2 = $[2];
+        t3 = $[3];
+        t4 = $[4];
+    }
+    let t5;
+    if ($[5] !== t1) {
+        t5 = _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, italic: true, children: _jsxs(Byline, { children: [t1, t2, t3, t4] }) }) });
+        $[5] = t1;
+        $[6] = t5;
+    }
+    else {
+        t5 = $[6];
+    }
+    return t5;
+}

package/dist/src/commands/plugin/usePagination.js

@@ -0,0 +1,89 @@
+import { useCallback, useMemo, useRef } from 'react';
+const DEFAULT_MAX_VISIBLE = 5;
+export function usePagination({ totalItems, maxVisible = DEFAULT_MAX_VISIBLE, selectedIndex = 0, }) {
+    const needsPagination = totalItems > maxVisible;
+    // Use a ref to track the previous scroll offset for smooth scrolling
+    const scrollOffsetRef = useRef(0);
+    // Compute the scroll offset based on selectedIndex
+    // This ensures the selected item is always visible
+    const scrollOffset = useMemo(() => {
+        if (!needsPagination)
+            return 0;
+        const prevOffset = scrollOffsetRef.current;
+        // If selected item is above the visible window, scroll up
+        if (selectedIndex < prevOffset) {
+            scrollOffsetRef.current = selectedIndex;
+            return selectedIndex;
+        }
+        // If selected item is below the visible window, scroll down
+        if (selectedIndex >= prevOffset + maxVisible) {
+            const newOffset = selectedIndex - maxVisible + 1;
+            scrollOffsetRef.current = newOffset;
+            return newOffset;
+        }
+        // Selected item is within visible window, keep current offset
+        // But ensure offset is still valid
+        const maxOffset = Math.max(0, totalItems - maxVisible);
+        const clampedOffset = Math.min(prevOffset, maxOffset);
+        scrollOffsetRef.current = clampedOffset;
+        return clampedOffset;
+    }, [selectedIndex, maxVisible, needsPagination, totalItems]);
+    const startIndex = scrollOffset;
+    const endIndex = Math.min(scrollOffset + maxVisible, totalItems);
+    const getVisibleItems = useCallback((items) => {
+        if (!needsPagination)
+            return items;
+        return items.slice(startIndex, endIndex);
+    }, [needsPagination, startIndex, endIndex]);
+    const toActualIndex = useCallback((visibleIndex) => {
+        return startIndex + visibleIndex;
+    }, [startIndex]);
+    const isOnCurrentPage = useCallback((actualIndex) => {
+        return actualIndex >= startIndex && actualIndex < endIndex;
+    }, [startIndex, endIndex]);
+    // These are mostly no-ops for continuous scrolling but kept for API compatibility
+    const goToPage = useCallback((_page) => {
+        // No-op - scrolling is controlled by selectedIndex
+    }, []);
+    const nextPage = useCallback(() => {
+        // No-op - scrolling is controlled by selectedIndex
+    }, []);
+    const prevPage = useCallback(() => {
+        // No-op - scrolling is controlled by selectedIndex
+    }, []);
+    // Simple selection handler - just updates the index
+    // Scrolling happens automatically via the useMemo above
+    const handleSelectionChange = useCallback((newIndex, setSelectedIndex) => {
+        const clampedIndex = Math.max(0, Math.min(newIndex, totalItems - 1));
+        setSelectedIndex(clampedIndex);
+    }, [totalItems]);
+    // Page navigation - disabled for continuous scrolling
+    const handlePageNavigation = useCallback((_direction, _setSelectedIndex) => {
+        return false;
+    }, []);
+    // Calculate page-like values for backwards compatibility
+    const totalPages = Math.max(1, Math.ceil(totalItems / maxVisible));
+    const currentPage = Math.floor(scrollOffset / maxVisible);
+    return {
+        currentPage,
+        totalPages,
+        startIndex,
+        endIndex,
+        needsPagination,
+        pageSize: maxVisible,
+        getVisibleItems,
+        toActualIndex,
+        isOnCurrentPage,
+        goToPage,
+        nextPage,
+        prevPage,
+        handleSelectionChange,
+        handlePageNavigation,
+        scrollPosition: {
+            current: selectedIndex + 1,
+            total: totalItems,
+            canScrollUp: scrollOffset > 0,
+            canScrollDown: scrollOffset + maxVisible < totalItems,
+        },
+    };
+}

package/dist/src/commands/policy/index.js

@@ -0,0 +1,9 @@
+const policy = {
+    type: 'local',
+    supportsNonInteractive: true,
+    name: 'policy',
+    description: 'Listar politicas de seleccion y fallback de Fase 4',
+    argumentHint: '[list|show <policy>]',
+    load: () => import('./policy.js'),
+};
+export default policy;

package/dist/src/commands/policy/policy.js

@@ -0,0 +1,84 @@
+import { DEFAULT_SCORING_WEIGHTS, parseSelectionPolicy, } from '../../services/orchestration/policy/index.js';
+import { parseArguments } from '../../utils/argumentSubstitution.js';
+const MODES = [
+    'manual',
+    'score',
+    'score-with-fallback',
+    'fallback-only',
+];
+const GOALS = [
+    'balanced',
+    'cost',
+    'latency',
+    'quality',
+    'capability',
+    'resilience',
+];
+function buildUsage() {
+    return [
+        'Uso:',
+        '/policy',
+        '/policy list',
+        '/policy show <mode[:goal]>',
+        '',
+        'Modos:',
+        ...MODES.map(mode => `- ${mode}`),
+        '',
+        'Objetivos:',
+        ...GOALS.map(goal => `- ${goal}`),
+        '',
+        'Ejemplo:',
+        '/policy show score-with-fallback:quality',
+    ].join('\n');
+}
+function listPolicies() {
+    return [
+        'Politicas disponibles:',
+        ...MODES.flatMap(mode => GOALS.map(goal => `- ${mode}:${goal}`)),
+        '',
+        'Uso operativo:',
+        '/run optimize <run-id> score-with-fallback:quality',
+        '/run assign <run-id> score:capability',
+        '/run fallback <run-id> <task-id> score-with-fallback:resilience',
+    ].join('\n');
+}
+function showPolicy(policyRef) {
+    const policy = parseSelectionPolicy(policyRef);
+    const weights = DEFAULT_SCORING_WEIGHTS[policy.optimizationGoal];
+    return [
+        `Policy: ${policy.id}`,
+        `Nombre: ${policy.name}`,
+        `Modo: ${policy.mode}`,
+        `Objetivo: ${policy.optimizationGoal}`,
+        `Cross-provider fallback: ${policy.allowCrossProviderFallback ? 'si' : 'no'}`,
+        `Fallback depth: ${policy.maxFallbackDepth}`,
+        'Pesos:',
+        `- capability=${weights.capability}`,
+        `- quality=${weights.quality}`,
+        `- cost=${weights.cost}`,
+        `- latency=${weights.latency}`,
+        `- availability=${weights.availability}`,
+        `- resilience=${weights.resilience}`,
+    ].join('\n');
+}
+export const call = async (args) => {
+    const tokens = parseArguments(args.trim());
+    const subcommand = tokens[0]?.toLowerCase() ?? 'list';
+    switch (subcommand) {
+        case 'list':
+            return {
+                type: 'text',
+                value: listPolicies(),
+            };
+        case 'show':
+            return {
+                type: 'text',
+                value: tokens[1] ? showPolicy(tokens[1]) : buildUsage(),
+            };
+        default:
+            return {
+                type: 'text',
+                value: buildUsage(),
+            };
+    }
+};

package/dist/src/commands/pr_comments/index.js

@@ -0,0 +1,49 @@
+import { createMovedToPluginCommand } from '../createMovedToPluginCommand.js';
+export default createMovedToPluginCommand({
+    name: 'pr-comments',
+    description: 'Obtener comentarios de una pull request de GitHub',
+    progressMessage: 'obteniendo comentarios de la PR',
+    pluginName: 'pr-comments',
+    pluginCommand: 'pr-comments',
+    async getPromptWhileMarketplaceIsPrivate(args) {
+        return [
+            {
+                type: 'text',
+                text: `You are an AI assistant integrated into a git-based version control system. Your task is to fetch and display comments from a GitHub pull request.
+
+Follow these steps:
+
+1. Use \`gh pr view --json number,headRepository\` to get the PR number and repository info
+2. Use \`gh api /repos/{owner}/{repo}/issues/{number}/comments\` to get PR-level comments
+3. Use \`gh api /repos/{owner}/{repo}/pulls/{number}/comments\` to get review comments. Pay particular attention to the following fields: \`body\`, \`diff_hunk\`, \`path\`, \`line\`, etc. If the comment references some code, consider fetching it using eg \`gh api /repos/{owner}/{repo}/contents/{path}?ref={branch} | jq .content -r | base64 -d\`
+4. Parse and format all comments in a readable way
+5. Return ONLY the formatted comments, with no additional text
+
+Format the comments as:
+
+## Comments
+
+[For each comment thread:]
+- @author file.ts#line:
+  \`\`\`diff
+  [diff_hunk from the API response]
+  \`\`\`
+  > quoted comment text
+
+  [any replies indented]
+
+If there are no comments, return "No comments found."
+
+Remember:
+1. Only show the actual comments, no explanatory text
+2. Include both PR-level and code review comments
+3. Preserve the threading/nesting of comment replies
+4. Show the file and line number context for code review comments
+5. Use jq to parse the JSON responses from the GitHub API
+
+${args ? 'Additional user input: ' + args : ''}
+`,
+            },
+        ];
+    },
+});

package/dist/src/commands/privacy-settings/index.js

@@ -0,0 +1,11 @@
+import { isConsumerSubscriber } from '../../utils/auth.js';
+const privacySettings = {
+    type: 'local-jsx',
+    name: 'privacy-settings',
+    description: 'Ver y actualizar tu configuración de privacidad',
+    isEnabled: () => {
+        return isConsumerSubscriber();
+    },
+    load: () => import('./privacy-settings.js'),
+};
+export default privacySettings;

package/dist/src/commands/privacy-settings/privacy-settings.js

@@ -0,0 +1,54 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { GroveDialog, PrivacySettingsDialog } from '../../components/grove/Grove.js';
+import { logEvent } from '../../services/analytics/index.js';
+import { getGroveNoticeConfig, getGroveSettings, isQualifiedForGrove } from '../../services/api/grove.js';
+const FALLBACK_MESSAGE = 'Review and manage your privacy settings at https://claude.ai/settings/data-privacy-controls';
+export async function call(onDone) {
+    const qualified = await isQualifiedForGrove();
+    if (!qualified) {
+        onDone(FALLBACK_MESSAGE);
+        return null;
+    }
+    const [settingsResult, configResult] = await Promise.all([getGroveSettings(), getGroveNoticeConfig()]);
+    // Hide dialog on API failure (after retry)
+    if (!settingsResult.success) {
+        onDone(FALLBACK_MESSAGE);
+        return null;
+    }
+    const settings = settingsResult.data;
+    const config = configResult.success ? configResult.data : null;
+    async function onDoneWithDecision(decision) {
+        if (decision === 'escape' || decision === 'defer') {
+            onDone('Privacy settings dialog dismissed', {
+                display: 'system'
+            });
+            return;
+        }
+        await onDoneWithSettingsCheck();
+    }
+    async function onDoneWithSettingsCheck() {
+        const updatedSettingsResult = await getGroveSettings();
+        if (!updatedSettingsResult.success) {
+            onDone('Unable to retrieve updated privacy settings', {
+                display: 'system'
+            });
+            return;
+        }
+        const updatedSettings = updatedSettingsResult.data;
+        const groveStatus = updatedSettings.grove_enabled ? 'true' : 'false';
+        onDone(`"Help improve Claude" set to ${groveStatus}.`);
+        if (settings.grove_enabled !== null && settings.grove_enabled !== updatedSettings.grove_enabled) {
+            logEvent('tengu_grove_policy_toggled', {
+                state: updatedSettings.grove_enabled,
+                location: 'settings'
+            });
+        }
+    }
+    // Show privacy settings directly if the user has already accepted the
+    // terms.
+    if (settings.grove_enabled !== null) {
+        return _jsx(PrivacySettingsDialog, { settings: settings, domainExcluded: config?.domain_excluded, onDone: onDoneWithSettingsCheck });
+    }
+    // Show the GroveDialog for users who haven't accepted terms yet
+    return _jsx(GroveDialog, { showIfAlreadyViewed: true, onDone: onDoneWithDecision, location: 'settings' });
+}

package/dist/src/commands/profile/index.js

@@ -0,0 +1,9 @@
+export default {
+    aliases: ['profiles'],
+    type: 'local-jsx',
+    name: 'profile',
+    description: 'Listar, inspeccionar y cambiar perfiles de proveedor',
+    argumentHint: '[list|current|migrate|use <proveedor> <perfil>|rename <proveedor> <actual> <nuevo>|remove <proveedor> <perfil>|remove all|model <proveedor> <perfil> <modelo|clear>]',
+    isEnabled: () => true,
+    load: () => import('./profile.js'),
+};