@iaforged/context-code 1.3.5 → 1.3.6

package/dist/src/core/session/legacy/tagCliAdapter.impl.js

@@ -0,0 +1,12 @@
+import { getSessionId } from '../../../bootstrap/state.js';
+import { logEvent } from '../../../services/analytics/index.js';
+import { recursivelySanitizeUnicode } from '../../../utils/sanitization.js';
+import { getCurrentSessionTag, getTranscriptPath, saveTag, } from '../../../utils/sessionStorage.js';
+export const tagCommandFlags = {
+    getSessionId,
+    logEvent,
+    recursivelySanitizeUnicode,
+    getCurrentSessionTag,
+    getTranscriptPath,
+    saveTag,
+};

package/dist/src/core/session/legacy/timelineCliAdapter.impl.js

@@ -0,0 +1,4 @@
+import { getSessionId } from '../../../bootstrap/state.js';
+import { logForDebugging } from '../../../utils/debug.js';
+import { formatRelativeTimeAgo, truncateToWidth } from '../../../utils/format.js';
+export { formatRelativeTimeAgo, getSessionId, logForDebugging, truncateToWidth, };

package/dist/src/core/session/legacy/vimCliAdapter.impl.js

@@ -0,0 +1,3 @@
+import { logEvent, } from '../../../services/analytics/index.js';
+import { getGlobalConfig, saveGlobalConfig } from '../../../utils/config.js';
+export { getGlobalConfig, logEvent, saveGlobalConfig, };

package/dist/src/core/session/memoryCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/memoryCliAdapter.impl.js';

package/dist/src/core/session/memoryCore.js

@@ -0,0 +1,44 @@
+export function buildMemoryEditorHintCore(input) {
+    if (input.visual) {
+        return `> Using $VISUAL="${input.visual}". To change editor, set $EDITOR or $VISUAL environment variable.`;
+    }
+    if (input.editor) {
+        return `> Using $EDITOR="${input.editor}". To change editor, set $EDITOR or $VISUAL environment variable.`;
+    }
+    return '> To use a different editor, set the $EDITOR or $VISUAL environment variable.';
+}
+export async function primeMemoryFilesCore(deps) {
+    deps.clearMemoryFileCaches();
+    await deps.getMemoryFiles();
+}
+export async function openMemoryFileCore(memoryPath, deps) {
+    try {
+        if (memoryPath.includes(deps.getClaudeConfigHomeDir())) {
+            await deps.mkdir(deps.getClaudeConfigHomeDir(), { recursive: true });
+        }
+        try {
+            await deps.writeFile(memoryPath, '', {
+                encoding: 'utf8',
+                flag: 'wx',
+            });
+        }
+        catch (error) {
+            if (deps.getErrnoCode(error) !== 'EEXIST') {
+                throw error;
+            }
+        }
+        await deps.editFileInEditor(memoryPath);
+        const editorHint = buildMemoryEditorHintCore({
+            visual: deps.getVisualEnv(),
+            editor: deps.getEditorEnv(),
+        });
+        return {
+            ok: true,
+            message: `Opened memory file at ${deps.getRelativeMemoryPath(memoryPath)}\n\n${editorHint}`,
+        };
+    }
+    catch (error) {
+        deps.logError(error);
+        return { ok: false, message: `Error opening memory file: ${error}` };
+    }
+}

package/dist/src/core/session/planCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/planCliAdapter.impl.js';

package/dist/src/core/session/planCore.js

@@ -0,0 +1,11 @@
+export function shouldEnablePlanModeCore(currentMode) {
+    return currentMode !== 'plan';
+}
+export function shouldPlanModeAutoQueryCore(args) {
+    const description = args.trim();
+    return description.length > 0 && description !== 'open';
+}
+export function isPlanOpenCommandCore(args) {
+    const argList = args.trim().split(/\s+/);
+    return argList[0] === 'open';
+}

package/dist/src/core/session/preflight.smoke.js

@@ -0,0 +1,153 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { filterResumableSessionsCore, findSessionInLogsByIdCore, resumeHelpMessageCore, } from './resumeCore.js';
+import { clearConversationCore } from './clearConversationCore.js';
+import { clearSessionCachesCore } from './clearCachesCore.js';
+import { getRemoteSessionMessage } from './sessionCore.js';
+import { isPlanOpenCommandCore, shouldEnablePlanModeCore, shouldPlanModeAutoQueryCore, } from './planCore.js';
+function resolveCliSrcRoot() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        resolve(here, '..', '..', '..'),
+        resolve(here, '..', '..', '..', '..', 'src'),
+    ];
+    for (const candidate of candidates) {
+        try {
+            readFileSync(resolve(candidate, 'commands.ts'), 'utf8');
+            return candidate;
+        }
+        catch { }
+    }
+    throw new Error('session preflight smoke: no se encontro CLI/src/commands.ts');
+}
+function verifyCoreSessionOrchestration() {
+    const logs = [
+        { id: 'a', isSidechain: false, sessionId: '11111111-1111-4111-8111-111111111111', modified: new Date() },
+        { id: 'b', isSidechain: true, sessionId: '22222222-2222-4222-8222-222222222222', modified: new Date() },
+    ];
+    const filtered = filterResumableSessionsCore(logs, '33333333-3333-4333-8333-333333333333');
+    assert.equal(filtered.length, 1);
+    const byId = findSessionInLogsByIdCore('11111111-1111-4111-8111-111111111111', logs);
+    assert.ok(byId);
+    assert.equal(byId?.sessionId, '11111111-1111-4111-8111-111111111111');
+    assert.equal(resumeHelpMessageCore({ resultType: 'sessionNotFound', arg: 'x' }), 'Session x was not found.');
+    const remoteOff = getRemoteSessionMessage(undefined);
+    assert.equal(remoteOff.isRemote, false);
+    assert.ok(remoteOff.warning);
+    assert.equal(shouldEnablePlanModeCore('normal'), true);
+    assert.equal(shouldEnablePlanModeCore('plan'), false);
+    assert.equal(shouldPlanModeAutoQueryCore('write a migration plan'), true);
+    assert.equal(shouldPlanModeAutoQueryCore('open'), false);
+    assert.equal(isPlanOpenCommandCore('open'), true);
+}
+function verifyCliSessionWiring(cliSrcRoot) {
+    const contextSrc = readFileSync(resolve(cliSrcRoot, 'commands', 'context', 'context.tsx'), 'utf8');
+    assert.ok(contextSrc.includes('collectContextDataCore'));
+    const compactSrc = readFileSync(resolve(cliSrcRoot, 'commands', 'compact', 'compact.ts'), 'utf8');
+    assert.ok(compactSrc.includes('executeCompactCore'));
+    const resumeSrc = readFileSync(resolve(cliSrcRoot, 'commands', 'resume', 'resume.tsx'), 'utf8');
+    assert.ok(resumeSrc.includes('formatResumeHelpCli'));
+    assert.ok(resumeSrc.includes('resolveResumeArgCli'));
+    const planSrc = readFileSync(resolve(cliSrcRoot, 'commands', 'plan', 'plan.tsx'), 'utf8');
+    assert.ok(planSrc.includes('applyPlanModeTransitionCli'));
+    assert.ok(planSrc.includes('shouldEnablePlanModeCore'));
+    const sessionSrc = readFileSync(resolve(cliSrcRoot, 'commands', 'session', 'session.tsx'), 'utf8');
+    assert.ok(sessionSrc.includes('getRemoteSessionMessage'));
+    const clearConvSrc = readFileSync(resolve(cliSrcRoot, 'commands', 'clear', 'conversation.ts'), 'utf8');
+    assert.ok(clearConvSrc.includes('clearConversationCore'));
+    assert.ok(clearConvSrc.includes('createClearConversationDeps'));
+    const clearCachesSrc = readFileSync(resolve(cliSrcRoot, 'commands', 'clear', 'caches.ts'), 'utf8');
+    assert.ok(clearCachesSrc.includes('clearSessionCachesCore'));
+    assert.ok(clearCachesSrc.includes('createClearSessionCachesDeps'));
+    const memorySrc = readFileSync(resolve(cliSrcRoot, 'commands', 'memory', 'memory.tsx'), 'utf8');
+    assert.ok(memorySrc.includes('openMemoryFileCore'));
+    assert.ok(memorySrc.includes('primeMemoryFilesCore'));
+    const renameSrc = readFileSync(resolve(cliSrcRoot, 'commands', 'rename', 'rename.ts'), 'utf8');
+    assert.ok(renameSrc.includes('renameSessionCore'));
+    assert.ok(renameSrc.includes('createRenameCoreDepsCli'));
+}
+async function verifyCoreClearOrchestration() {
+    const calls = [];
+    clearSessionCachesCore({
+        clearContextCaches: () => calls.push('context'),
+        clearFileSuggestionCaches: () => calls.push('fileSuggestions'),
+        clearCommandsCache: () => calls.push('commands'),
+        resetPromptCacheBreakDetection: () => calls.push('cacheBreak'),
+        clearSystemPromptInjection: () => calls.push('systemInjection'),
+        clearLastEmittedDate: () => calls.push('lastDate'),
+        runPostCompactCleanup: () => calls.push('postCompact'),
+        resetSentSkillNames: () => calls.push('sentSkillNames'),
+        resetGetMemoryFilesCache: () => calls.push('memoryFiles'),
+        clearStoredImagePaths: () => calls.push('images'),
+        clearAllSessions: () => calls.push('sessions'),
+        clearAllPendingCallbacks: () => calls.push('callbacks'),
+        clearTungstenUsageCaches: () => calls.push('tungsten'),
+        clearAttributionCaches: () => calls.push('attribution'),
+        clearRepositoryCaches: () => calls.push('repository'),
+        clearCommandPrefixCaches: () => calls.push('commandPrefix'),
+        clearAllDumpState: () => calls.push('dump'),
+        clearInvokedSkills: () => calls.push('invokedSkills'),
+        clearResolveGitDirCache: () => calls.push('gitDir'),
+        clearDynamicSkills: () => calls.push('dynamicSkills'),
+        resetAllLspDiagnosticState: () => calls.push('lsp'),
+        clearTrackedMagicDocs: () => calls.push('magicDocs'),
+        clearSessionEnvVars: () => calls.push('sessionEnv'),
+        clearWebFetchCache: () => calls.push('webFetch'),
+        clearToolSearchDescriptionCache: () => calls.push('toolSearch'),
+        clearAgentDefinitionsCache: () => calls.push('agents'),
+        clearSkillPromptCache: () => calls.push('skillPrompt'),
+    }, new Set(['a']));
+    assert.ok(calls.includes('context'));
+    assert.ok(calls.includes('sessions'));
+    const clearCalls = [];
+    await clearConversationCore({
+        hasProactiveFeature: true,
+        hasCoordinatorModeFeature: true,
+        lastRequestId: 'req-1',
+        originalCwd: '/tmp',
+        userType: 'ant',
+        envSessionId: 'old',
+        shouldUpdateEnvSessionId: false,
+    }, {
+        getSessionEndHookTimeoutMs: () => 10,
+        executeSessionEndHooks: async () => clearCalls.push('endHooks'),
+        logCacheEvictionHint: () => clearCalls.push('evictionHint'),
+        setMessagesEmpty: () => clearCalls.push('messagesEmpty'),
+        setContextBlocked: () => clearCalls.push('contextUnblocked'),
+        setConversationId: () => clearCalls.push('conversationId'),
+        clearSessionCaches: () => clearCalls.push('clearCaches'),
+        setCwd: () => clearCalls.push('setCwd'),
+        clearReadFileState: () => clearCalls.push('readFileState'),
+        clearDiscoveredSkillNames: () => clearCalls.push('skills'),
+        clearLoadedNestedMemoryPaths: () => clearCalls.push('memoryPaths'),
+        getPreservedTaskSnapshot: () => ({
+            preservedAgentIds: new Set(['a']),
+            preservedLocalAgentTaskIds: ['t1'],
+        }),
+        clearAppState: () => clearCalls.push('clearAppState'),
+        clearPlanSlugs: () => clearCalls.push('planSlugs'),
+        clearSessionMetadata: () => clearCalls.push('sessionMetadata'),
+        regenerateSessionId: () => clearCalls.push('regenSession'),
+        getSessionId: () => 'new-session',
+        resetSessionFilePointer: async () => clearCalls.push('resetPointer'),
+        refreshRunningTaskOutputLinks: () => clearCalls.push('symlinks'),
+        saveMode: () => clearCalls.push('saveMode'),
+        saveWorktreeState: () => clearCalls.push('saveWorktree'),
+        processSessionStartHooks: async () => [{ role: 'system', content: 'ok' }],
+        setMessagesToHookMessages: () => clearCalls.push('hookMessages'),
+    });
+    assert.ok(clearCalls.includes('clearCaches'));
+    assert.ok(clearCalls.includes('hookMessages'));
+}
+export async function runSessionPreflightSmoke() {
+    verifyCoreSessionOrchestration();
+    await verifyCoreClearOrchestration();
+    verifyCliSessionWiring(resolveCliSrcRoot());
+}
+const isDirectRun = process.argv[1]?.endsWith('preflight.smoke.js');
+if (isDirectRun) {
+    await runSessionPreflightSmoke();
+    console.log('session preflight smoke: ok');
+}

package/dist/src/core/session/releaseNotesCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/releaseNotesCliAdapter.impl.js';

package/dist/src/core/session/releaseNotesCore.js

@@ -0,0 +1,17 @@
+export function formatReleaseNotesCore(notes, translate) {
+    return notes
+        .map(([version, versionNotes]) => {
+        const header = `Versión ${version}:`;
+        const bulletPoints = versionNotes
+            .map(note => `- ${translate(note)}`)
+            .join('\n');
+        return `${header}\n${bulletPoints}`;
+    })
+        .join('\n\n');
+}
+export async function withTimeoutCore(work, timeoutMs) {
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error('Timeout')), timeoutMs);
+    });
+    return Promise.race([work(), timeoutPromise]);
+}

package/dist/src/core/session/renameCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/renameCliAdapter.impl.js';

package/dist/src/core/session/renameCore.js

@@ -0,0 +1,26 @@
+export async function renameSessionCore(input, deps) {
+    if (input.isTeammate) {
+        return {
+            status: 'blocked',
+            message: 'Cannot rename: This session is a swarm teammate. Teammate names are set by the team leader.',
+        };
+    }
+    let newName = input.args.trim();
+    if (!newName) {
+        const generated = await deps.generateSessionName(input.messages, input.signal);
+        if (!generated) {
+            return {
+                status: 'error',
+                message: 'Could not generate a name: no conversation context yet. Usage: /rename <name>',
+            };
+        }
+        newName = generated;
+    }
+    await deps.saveCustomTitle(newName);
+    if (input.bridgeSessionId) {
+        void deps.updateBridgeSessionTitle(input.bridgeSessionId, newName).catch(() => { });
+    }
+    await deps.saveAgentName(newName);
+    deps.setStandaloneAgentName(newName);
+    return { status: 'renamed', name: newName, message: `Session renamed to: ${newName}` };
+}

package/dist/src/core/session/resumeCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/resumeCliAdapter.impl.js';

package/dist/src/core/session/resumeCommandCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/resumeCommandCliAdapter.impl.js';

package/dist/src/core/session/resumeCore.js

@@ -0,0 +1,24 @@
+import chalk from 'chalk';
+import { getSessionIdFromLog, validateUuid } from './legacy/resumeCoreCliAdapter.js';
+export function resumeHelpMessageCore(result) {
+    switch (result.resultType) {
+        case 'sessionNotFound':
+            return `Session ${chalk.bold(result.arg)} was not found.`;
+        case 'multipleMatches':
+            return `Found ${result.count} sessions matching ${chalk.bold(result.arg)}. Please use /resume to pick a specific session.`;
+    }
+}
+export function filterResumableSessionsCore(logs, currentSessionId) {
+    return logs.filter(l => !l.isSidechain && getSessionIdFromLog(l) !== currentSessionId);
+}
+export function findSessionInLogsByIdCore(arg, logs) {
+    const maybeSessionId = validateUuid(arg);
+    if (!maybeSessionId)
+        return null;
+    const matchingLogs = logs
+        .filter(l => getSessionIdFromLog(l) === maybeSessionId)
+        .sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    if (matchingLogs.length === 0)
+        return null;
+    return { sessionId: maybeSessionId, log: matchingLogs[0] };
+}

package/dist/src/core/session/resumenCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/resumenCliAdapter.impl.js';

package/dist/src/core/session/resumenCore.js

@@ -0,0 +1,15 @@
+import { listOrchestrationRuns, parseArguments } from './resumenCliAdapter.js';
+export async function resolveResumenRunId(args) {
+    const parsedArgs = parseArguments(args);
+    const providedRunId = parsedArgs[0];
+    if (providedRunId) {
+        return { runId: providedRunId };
+    }
+    const runs = await listOrchestrationRuns();
+    if (runs.length === 0) {
+        return {
+            error: 'No se encontraron ejecuciones de orquestación previas.',
+        };
+    }
+    return { runId: runs[0].id };
+}

package/dist/src/core/session/sessionCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/sessionCliAdapter.impl.js';

package/dist/src/core/session/sessionCore.js

@@ -0,0 +1,9 @@
+export function getRemoteSessionMessage(remoteSessionUrl) {
+    if (!remoteSessionUrl) {
+        return {
+            isRemote: false,
+            warning: 'Not in remote mode. Start with `context --remote` to use this command.',
+        };
+    }
+    return { isRemote: true };
+}

package/dist/src/core/session/tagCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/tagCliAdapter.impl.js';

package/dist/src/core/session/tagCore.js

@@ -0,0 +1,16 @@
+export const TAG_HELP_TEXT = 'Usage: /tag <tag-name>\n\nToggle a searchable tag on the current session.\nRun the same command again to remove the tag.\nTags are displayed after the branch name in /resume and can be searched with /.\n\nExamples:\n  /tag bugfix        # Add tag\n  /tag bugfix        # Remove tag (toggle)\n  /tag feature-auth\n  /tag wip';
+export function normalizeTagNameCore(input, sanitize) {
+    return sanitize(input).trim();
+}
+export function resolveTagActionCore(sessionId, normalizedTag, currentTag) {
+    if (!sessionId) {
+        return { type: 'no_session' };
+    }
+    if (!normalizedTag) {
+        return { type: 'empty_tag' };
+    }
+    if (currentTag === normalizedTag) {
+        return { type: 'confirm_remove' };
+    }
+    return { type: 'set_tag' };
+}

package/dist/src/core/session/timelineCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/timelineCliAdapter.impl.js';

package/dist/src/core/session/vimCliAdapter.js

@@ -0,0 +1 @@
+export * from './legacy/vimCliAdapter.impl.js';

package/dist/src/core/session/vimCore.js

@@ -0,0 +1,14 @@
+export function normalizeEditorMode(mode) {
+    if (mode === 'vim')
+        return 'vim';
+    return 'normal';
+}
+export function toggleEditorMode(currentMode) {
+    const normalized = normalizeEditorMode(currentMode);
+    return normalized === 'normal' ? 'vim' : 'normal';
+}
+export function formatEditorModeMessage(newMode) {
+    return `Editor mode set to ${newMode}. ${newMode === 'vim'
+        ? 'Use Escape key to toggle between INSERT and NORMAL modes.'
+        : 'Using standard (readline) keyboard bindings.'}`;
+}

package/dist/src/core/sharedLegacyDeps/pluginsCliAdapterDeps.js

@@ -0,0 +1,45 @@
+import { useMcpToggleEnabled } from '../../services/mcp/MCPConnectionManager.js';
+import { checkStatsigFeatureGate_CACHED_MAY_BE_STALE } from '../../services/analytics/growthbook.js';
+import { useExitOnCtrlCDWithKeybindings } from '../../hooks/useExitOnCtrlCDWithKeybindings.js';
+import { useSearchInput } from '../../hooks/useSearchInput.js';
+import { useTerminalSize } from '../../hooks/useTerminalSize.js';
+import { useAppState, useSetAppState } from '../../state/AppState.js';
+import { isEnvTruthy } from '../../utils/envUtils.js';
+import { filterToolsByServer } from '../../services/mcp/utils.js';
+import { disablePluginOp, enablePluginOp, getPluginInstallationFromV2, isInstallableScope, isPluginEnabledAtProjectScope, uninstallPluginOp, updatePluginOp, } from '../../services/plugins/pluginOperations.js';
+import { count } from '../../utils/array.js';
+import { openBrowser } from '../../utils/browser.js';
+import { shouldSkipPluginAutoupdate } from '../../utils/config.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { errorMessage, isENOENT, toError } from '../../utils/errors.js';
+import { execFileNoThrow } from '../../utils/execFileNoThrow.js';
+import { pathExists } from '../../utils/file.js';
+import { logError } from '../../utils/log.js';
+import { getPlatform } from '../../utils/platform.js';
+import { clearAllCaches } from '../../utils/plugins/cacheUtils.js';
+import { formatInstallCount, getInstallCounts } from '../../utils/plugins/installCounts.js';
+import { isPluginGloballyInstalled, isPluginInstalled, loadInstalledPluginsV2, } from '../../utils/plugins/installedPluginsManager.js';
+import { createPluginId, detectEmptyMarketplaceReason, formatFailureDetails, formatMarketplaceLoadingErrors, getPluginTrustMessage, getMarketplaceSourceDisplay, loadMarketplacesWithGracefulDegradation, } from '../../utils/plugins/marketplaceHelpers.js';
+import { addMarketplaceSource, clearMarketplacesCache, getMarketplace, loadKnownMarketplacesConfig, refreshMarketplace, removeMarketplaceSource, setMarketplaceAutoUpdate, } from '../../utils/plugins/marketplaceManager.js';
+import { isMcpbSource, loadMcpbFile } from '../../utils/plugins/mcpbHandler.js';
+import { OFFICIAL_MARKETPLACE_NAME } from '../../utils/plugins/officialMarketplace.js';
+import { updatePluginsForMarketplaces } from '../../utils/plugins/pluginAutoupdate.js';
+import { getPluginDataDirSize, pluginDataDirPath } from '../../utils/plugins/pluginDirectories.js';
+import { getFlaggedPlugins, markFlaggedPluginsSeen, removeFlaggedPlugin, } from '../../utils/plugins/pluginFlagging.js';
+import { parsePluginIdentifier, } from '../../utils/plugins/pluginIdentifier.js';
+import { installPluginFromMarketplace } from '../../utils/plugins/pluginInstallationHelpers.js';
+import { loadAllPlugins } from '../../utils/plugins/pluginLoader.js';
+import { parseMarketplaceInput } from '../../utils/plugins/parseMarketplaceInput.js';
+import { loadPluginOptions, savePluginOptions, } from '../../utils/plugins/pluginOptionsStorage.js';
+import { isPluginBlockedByPolicy } from '../../utils/plugins/pluginPolicy.js';
+import { getPluginEditableScopes, installSelectedPlugins, } from '../../utils/plugins/pluginStartupCheck.js';
+import { isMarketplaceAutoUpdate } from '../../utils/plugins/schemas.js';
+import { getSettings_DEPRECATED, getSettingsForSource, updateSettingsForSource, } from '../../utils/settings/settings.js';
+import { jsonParse } from '../../utils/slowOperations.js';
+import { plural } from '../../utils/stringUtils.js';
+import { truncateToWidth } from '../../utils/truncate.js';
+import { getUnconfiguredChannels, } from '../../utils/plugins/mcpPluginIntegration.js';
+import { loadMcpServerUserConfig, saveMcpServerUserConfig, } from '../../utils/plugins/mcpbHandler.js';
+import { getUnconfiguredOptions } from '../../utils/plugins/pluginOptionsStorage.js';
+import { validateManifest } from '../../utils/plugins/validatePlugin.js';
+export { addMarketplaceSource, checkStatsigFeatureGate_CACHED_MAY_BE_STALE, clearAllCaches, clearMarketplacesCache, count, createPluginId, detectEmptyMarketplaceReason, disablePluginOp, enablePluginOp, errorMessage, execFileNoThrow, filterToolsByServer, formatFailureDetails, formatInstallCount, formatMarketplaceLoadingErrors, getFlaggedPlugins, getInstallCounts, getMarketplace, getMarketplaceSourceDisplay, getPlatform, getPluginDataDirSize, getPluginEditableScopes, getPluginInstallationFromV2, getPluginTrustMessage, getSettings_DEPRECATED, getSettingsForSource, getUnconfiguredChannels, getUnconfiguredOptions, installPluginFromMarketplace, installSelectedPlugins, isENOENT, isEnvTruthy, isInstallableScope, isMarketplaceAutoUpdate, isMcpbSource, isPluginBlockedByPolicy, isPluginEnabledAtProjectScope, isPluginGloballyInstalled, isPluginInstalled, jsonParse, loadAllPlugins, loadInstalledPluginsV2, loadKnownMarketplacesConfig, loadMarketplacesWithGracefulDegradation, loadMcpbFile, loadMcpServerUserConfig, loadPluginOptions, logError, logForDebugging, markFlaggedPluginsSeen, OFFICIAL_MARKETPLACE_NAME, openBrowser, parseMarketplaceInput, parsePluginIdentifier, pathExists, pluginDataDirPath, plural, refreshMarketplace, removeFlaggedPlugin, removeMarketplaceSource, saveMcpServerUserConfig, savePluginOptions, setMarketplaceAutoUpdate, shouldSkipPluginAutoupdate, toError, truncateToWidth, uninstallPluginOp, updatePluginOp, updatePluginsForMarketplaces, updateSettingsForSource, useAppState, useExitOnCtrlCDWithKeybindings, useMcpToggleEnabled, useSearchInput, useSetAppState, useTerminalSize, validateManifest, };

package/dist/src/core/sharedLegacyDeps/pluginsReloadDeps.js

@@ -0,0 +1,8 @@
+import { feature } from '../../recovery/bunBundleShim.js';
+import { getIsRemoteMode } from '../../bootstrap/state.js';
+import { redownloadUserSettings } from '../../services/settingsSync/index.js';
+import { isEnvTruthy } from '../../utils/envUtils.js';
+import { refreshActivePlugins } from '../../utils/plugins/refresh.js';
+import { settingsChangeDetector } from '../../utils/settings/changeDetector.js';
+import { plural } from '../../utils/stringUtils.js';
+export { feature, getIsRemoteMode, isEnvTruthy, plural, redownloadUserSettings, refreshActivePlugins, settingsChangeDetector, };

package/dist/src/core/sharedLegacyDeps/skillsCliAdapterDeps.js

@@ -0,0 +1,8 @@
+import { getBuiltinPluginSkillCommands } from '../../plugins/builtinPlugins.js';
+import { getBundledSkills } from '../../skills/bundledSkills.js';
+import { clearSkillCaches, getSkillDirCommands } from '../../skills/loadSkillsDir.js';
+import { clearPluginSkillsCache, getPluginSkills, } from '../../utils/plugins/loadPluginCommands.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { toError } from '../../utils/errors.js';
+import { logError } from '../../utils/log.js';
+export { clearPluginSkillsCache, clearSkillCaches, getBuiltinPluginSkillCommands, getBundledSkills, getPluginSkills, getSkillDirCommands, logError, logForDebugging, toError, };

package/dist/src/core/skills/importCore.js

@@ -0,0 +1,66 @@
+const KNOWN_IMPORT_SOURCES = ['.claude', '.context', '.codex', '.agents'];
+export function resolveSkillImportSources(args, cwd, pathOps) {
+    let cleanArgs = args.trim();
+    if (cleanArgs.toLowerCase().startsWith('import')) {
+        cleanArgs = cleanArgs.substring('import'.length).trim();
+    }
+    if (!cleanArgs) {
+        return KNOWN_IMPORT_SOURCES.map(source => pathOps.resolve(cwd, source));
+    }
+    return [pathOps.resolve(cwd, cleanArgs)];
+}
+export async function importSkillsToContext(context) {
+    const { cwd, args, fs, paths } = context;
+    const targetRoot = paths.resolve(cwd, '.context', 'skills');
+    const sources = resolveSkillImportSources(args, cwd, paths);
+    const imported = [];
+    const skipped = [];
+    await fs.mkdir(targetRoot);
+    for (const sourceRoot of sources) {
+        if (!(await fs.exists(sourceRoot))) {
+            skipped.push(`${sourceRoot} (no existe)`);
+            continue;
+        }
+        const searchFolders = [sourceRoot, paths.join(sourceRoot, 'skills')];
+        for (const folder of searchFolders) {
+            if (!(await fs.exists(folder)))
+                continue;
+            const entries = await fs.readDir(folder);
+            for (const entry of entries) {
+                if (!entry.isDirectory && !entry.isSymbolicLink)
+                    continue;
+                const sourceSkillDir = paths.join(folder, entry.name);
+                const sourceSkillFile = paths.join(sourceSkillDir, 'SKILL.md');
+                if (!(await fs.exists(sourceSkillFile)))
+                    continue;
+                const targetSkillDir = paths.join(targetRoot, paths.basename(entry.name));
+                if (await fs.exists(targetSkillDir)) {
+                    if (!imported.some(item => item.startsWith(entry.name))) {
+                        skipped.push(`${entry.name} (ya existe en .context/skills)`);
+                    }
+                    continue;
+                }
+                await fs.copyDir(sourceSkillDir, targetSkillDir);
+                imported.push(`${entry.name} <- ${folder}`);
+            }
+        }
+    }
+    if (imported.length === 0 && skipped.length === 0) {
+        skipped.push('No se encontraron skills válidas en las fuentes proporcionadas.');
+    }
+    return { targetRoot, imported, skipped };
+}
+export function formatSkillsImportResult(result) {
+    const lines = ['Importacion de skills finalizada.', `Destino: ${result.targetRoot}`];
+    lines.push(`Importados: ${result.imported.length}`);
+    for (const item of result.imported) {
+        lines.push(`- ${item}`);
+    }
+    if (result.skipped.length > 0) {
+        lines.push(`Omitidos: ${result.skipped.length}`);
+        for (const item of result.skipped) {
+            lines.push(`- ${item}`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/src/core/skills/importCore.smoke.js

@@ -0,0 +1,49 @@
+import assert from 'node:assert/strict';
+import { formatSkillsImportResult, importSkillsToContext, resolveSkillImportSources, } from './importCore.js';
+const seenCopies = [];
+const existing = new Set([
+    '/repo/.claude',
+    '/repo/.claude/skills',
+    '/repo/.claude/skills/alpha',
+    '/repo/.claude/skills/alpha/SKILL.md',
+]);
+const fsAdapter = {
+    async exists(path) {
+        return existing.has(path);
+    },
+    async mkdir(path) {
+        existing.add(path);
+    },
+    async readDir(path) {
+        if (path === '/repo/.claude') {
+            return [{ name: 'skills', isDirectory: true, isSymbolicLink: false }];
+        }
+        if (path === '/repo/.claude/skills') {
+            return [{ name: 'alpha', isDirectory: true, isSymbolicLink: false }];
+        }
+        return [];
+    },
+    async copyDir(source, target) {
+        seenCopies.push({ source, target });
+        existing.add(target);
+        existing.add(`${target}/SKILL.md`);
+    },
+};
+const pathOps = {
+    resolve: (...parts) => parts.join('/').replace('src//', '/'),
+    join: (...parts) => parts.join('/').replace('src//', '/'),
+    basename: (path) => path.split('/').at(-1) ?? path,
+};
+const sources = resolveSkillImportSources('import', '/repo', pathOps);
+assert.equal(sources.length, 4);
+const result = await importSkillsToContext({
+    cwd: '/repo',
+    args: 'import .claude',
+    fs: fsAdapter,
+    paths: pathOps,
+});
+assert.equal(result.imported.length, 1);
+assert.equal(result.skipped.length, 0);
+assert.equal(seenCopies.length, 1);
+assert.match(formatSkillsImportResult(result), /Importados: 1/);
+console.log('skills.importCore.smoke PASS');

package/dist/src/core/skills/legacy/bootstrap/state.js

@@ -0,0 +1 @@
+export * from '../../../../bootstrap/state.js';

package/dist/src/core/skills/legacy/cliAdapter.impl.js

@@ -0,0 +1,32 @@
+import { clearPluginSkillsCache, clearSkillCaches, getBuiltinPluginSkillCommands, getBundledSkills, getPluginSkills, getSkillDirCommands, logError, logForDebugging, toError, } from '../../sharedLegacyDeps/skillsCliAdapterDeps.js';
+import { CoreSkillsIndex, registerDefaultCoreSkillsIndex, } from '../index.js';
+const cliSkillSourcesLoader = {
+    loadSkillDirCommands: async (cwd) => {
+        try {
+            return await getSkillDirCommands(cwd);
+        }
+        catch (err) {
+            logError(toError(err));
+            logForDebugging('Core skill directory commands failed to load, continuing without them');
+            return [];
+        }
+    },
+    loadPluginSkills: async () => {
+        try {
+            return await getPluginSkills();
+        }
+        catch (err) {
+            logError(toError(err));
+            logForDebugging('Core plugin skills failed to load, continuing without them');
+            return [];
+        }
+    },
+    loadBundledSkills: getBundledSkills,
+    loadBuiltinPluginCommands: getBuiltinPluginSkillCommands,
+};
+const cliSkillCacheManager = {
+    clearSkillCaches,
+    clearPluginSkillsCache,
+};
+export const coreSkillsIndex = new CoreSkillsIndex(cliSkillSourcesLoader, cliSkillCacheManager);
+registerDefaultCoreSkillsIndex(coreSkillsIndex);

package/dist/src/core/skills/legacy/services/SessionMemory/sessionMemoryUtils.js

@@ -0,0 +1 @@
+export * from '../../../../../services/SessionMemory/sessionMemoryUtils.js';

package/dist/src/core/skills/legacy/services/analytics/growthbook.js

@@ -0,0 +1 @@
+export * from '../../../../../services/analytics/growthbook.js';

package/dist/src/core/skills/legacy/services/analytics/index.js

@@ -0,0 +1 @@
+export * from '../../../../../services/analytics/index.js';

package/dist/src/core/skills/legacy/services/mcp/types.js

@@ -0,0 +1 @@
+export * from '../../../../../services/mcp/types.js';