claude-flow-novice 2.2.1 → 2.2.3

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/contrib/codeAction/browser/codeActionModel.js

@@ -0,0 +1,271 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createCancelablePromise, TimeoutTimer } from '../../../../base/common/async.js';
+import { isCancellationError } from '../../../../base/common/errors.js';
+import { Emitter } from '../../../../base/common/event.js';
+import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { isEqual } from '../../../../base/common/resources.js';
+import { ShowAiIconMode } from '../../../common/config/editorOptions.js';
+import { Position } from '../../../common/core/position.js';
+import { Selection } from '../../../common/core/selection.js';
+import { RawContextKey } from '../../../../platform/contextkey/common/contextkey.js';
+import { Progress } from '../../../../platform/progress/common/progress.js';
+import { CodeActionKind, CodeActionTriggerSource } from '../common/types.js';
+import { getCodeActions } from './codeAction.js';
+export const SUPPORTED_CODE_ACTIONS = new RawContextKey('supportedCodeAction', '');
+class CodeActionOracle extends Disposable {
+    constructor(_editor, _markerService, _signalChange, _delay = 250) {
+        super();
+        this._editor = _editor;
+        this._markerService = _markerService;
+        this._signalChange = _signalChange;
+        this._delay = _delay;
+        this._autoTriggerTimer = this._register(new TimeoutTimer());
+        this._register(this._markerService.onMarkerChanged(e => this._onMarkerChanges(e)));
+        this._register(this._editor.onDidChangeCursorPosition(() => this._tryAutoTrigger()));
+    }
+    trigger(trigger) {
+        const selection = this._getRangeOfSelectionUnlessWhitespaceEnclosed(trigger);
+        this._signalChange(selection ? { trigger, selection } : undefined);
+    }
+    _onMarkerChanges(resources) {
+        const model = this._editor.getModel();
+        if (model && resources.some(resource => isEqual(resource, model.uri))) {
+            this._tryAutoTrigger();
+        }
+    }
+    _tryAutoTrigger() {
+        this._autoTriggerTimer.cancelAndSet(() => {
+            this.trigger({ type: 2 /* CodeActionTriggerType.Auto */, triggerAction: CodeActionTriggerSource.Default });
+        }, this._delay);
+    }
+    _getRangeOfSelectionUnlessWhitespaceEnclosed(trigger) {
+        var _a;
+        if (!this._editor.hasModel()) {
+            return undefined;
+        }
+        const model = this._editor.getModel();
+        const selection = this._editor.getSelection();
+        if (selection.isEmpty() && trigger.type === 2 /* CodeActionTriggerType.Auto */) {
+            const { lineNumber, column } = selection.getPosition();
+            const line = model.getLineContent(lineNumber);
+            if (line.length === 0) {
+                // empty line
+                const showAiIconOnEmptyLines = ((_a = this._editor.getOption(64 /* EditorOption.lightbulb */).experimental) === null || _a === void 0 ? void 0 : _a.showAiIcon) === ShowAiIconMode.On;
+                if (!showAiIconOnEmptyLines) {
+                    return undefined;
+                }
+            }
+            else if (column === 1) {
+                // look only right
+                if (/\s/.test(line[0])) {
+                    return undefined;
+                }
+            }
+            else if (column === model.getLineMaxColumn(lineNumber)) {
+                // look only left
+                if (/\s/.test(line[line.length - 1])) {
+                    return undefined;
+                }
+            }
+            else {
+                // look left and right
+                if (/\s/.test(line[column - 2]) && /\s/.test(line[column - 1])) {
+                    return undefined;
+                }
+            }
+        }
+        return selection;
+    }
+}
+export var CodeActionsState;
+(function (CodeActionsState) {
+    CodeActionsState.Empty = { type: 0 /* Type.Empty */ };
+    class Triggered {
+        constructor(trigger, position, _cancellablePromise) {
+            this.trigger = trigger;
+            this.position = position;
+            this._cancellablePromise = _cancellablePromise;
+            this.type = 1 /* Type.Triggered */;
+            this.actions = _cancellablePromise.catch((e) => {
+                if (isCancellationError(e)) {
+                    return emptyCodeActionSet;
+                }
+                throw e;
+            });
+        }
+        cancel() {
+            this._cancellablePromise.cancel();
+        }
+    }
+    CodeActionsState.Triggered = Triggered;
+})(CodeActionsState || (CodeActionsState = {}));
+const emptyCodeActionSet = Object.freeze({
+    allActions: [],
+    validActions: [],
+    dispose: () => { },
+    documentation: [],
+    hasAutoFix: false,
+    hasAIFix: false,
+    allAIFixes: false,
+});
+export class CodeActionModel extends Disposable {
+    constructor(_editor, _registry, _markerService, contextKeyService, _progressService, _configurationService) {
+        super();
+        this._editor = _editor;
+        this._registry = _registry;
+        this._markerService = _markerService;
+        this._progressService = _progressService;
+        this._configurationService = _configurationService;
+        this._codeActionOracle = this._register(new MutableDisposable());
+        this._state = CodeActionsState.Empty;
+        this._onDidChangeState = this._register(new Emitter());
+        this.onDidChangeState = this._onDidChangeState.event;
+        this._disposed = false;
+        this._supportedCodeActions = SUPPORTED_CODE_ACTIONS.bindTo(contextKeyService);
+        this._register(this._editor.onDidChangeModel(() => this._update()));
+        this._register(this._editor.onDidChangeModelLanguage(() => this._update()));
+        this._register(this._registry.onDidChange(() => this._update()));
+        this._update();
+    }
+    dispose() {
+        if (this._disposed) {
+            return;
+        }
+        this._disposed = true;
+        super.dispose();
+        this.setState(CodeActionsState.Empty, true);
+    }
+    _settingEnabledNearbyQuickfixes() {
+        var _a;
+        const model = (_a = this._editor) === null || _a === void 0 ? void 0 : _a.getModel();
+        return this._configurationService ? this._configurationService.getValue('editor.codeActionWidget.includeNearbyQuickFixes', { resource: model === null || model === void 0 ? void 0 : model.uri }) : false;
+    }
+    _update() {
+        if (this._disposed) {
+            return;
+        }
+        this._codeActionOracle.value = undefined;
+        this.setState(CodeActionsState.Empty);
+        const model = this._editor.getModel();
+        if (model
+            && this._registry.has(model)
+            && !this._editor.getOption(90 /* EditorOption.readOnly */)) {
+            const supportedActions = this._registry.all(model).flatMap(provider => { var _a; return (_a = provider.providedCodeActionKinds) !== null && _a !== void 0 ? _a : []; });
+            this._supportedCodeActions.set(supportedActions.join(' '));
+            this._codeActionOracle.value = new CodeActionOracle(this._editor, this._markerService, trigger => {
+                var _a;
+                if (!trigger) {
+                    this.setState(CodeActionsState.Empty);
+                    return;
+                }
+                const startPosition = trigger.selection.getStartPosition();
+                const actions = createCancelablePromise(async (token) => {
+                    var _a, _b, _c, _d, _e, _f;
+                    if (this._settingEnabledNearbyQuickfixes() && trigger.trigger.type === 1 /* CodeActionTriggerType.Invoke */ && (trigger.trigger.triggerAction === CodeActionTriggerSource.QuickFix || ((_b = (_a = trigger.trigger.filter) === null || _a === void 0 ? void 0 : _a.include) === null || _b === void 0 ? void 0 : _b.contains(CodeActionKind.QuickFix)))) {
+                        const codeActionSet = await getCodeActions(this._registry, model, trigger.selection, trigger.trigger, Progress.None, token);
+                        const allCodeActions = [...codeActionSet.allActions];
+                        if (token.isCancellationRequested) {
+                            return emptyCodeActionSet;
+                        }
+                        // Search for quickfixes in the curret code action set.
+                        const foundQuickfix = (_c = codeActionSet.validActions) === null || _c === void 0 ? void 0 : _c.some(action => action.action.kind ? CodeActionKind.QuickFix.contains(new CodeActionKind(action.action.kind)) : false);
+                        if (!foundQuickfix) {
+                            const allMarkers = this._markerService.read({ resource: model.uri });
+                            // If markers exists, and there are no quickfixes found or length is zero, check for quickfixes on that line.
+                            if (allMarkers.length > 0) {
+                                const currPosition = trigger.selection.getPosition();
+                                let trackedPosition = currPosition;
+                                let distance = Number.MAX_VALUE;
+                                const currentActions = [...codeActionSet.validActions];
+                                for (const marker of allMarkers) {
+                                    const col = marker.endColumn;
+                                    const row = marker.endLineNumber;
+                                    const startRow = marker.startLineNumber;
+                                    // Found quickfix on the same line and check relative distance to other markers
+                                    if ((row === currPosition.lineNumber || startRow === currPosition.lineNumber)) {
+                                        trackedPosition = new Position(row, col);
+                                        const newCodeActionTrigger = {
+                                            type: trigger.trigger.type,
+                                            triggerAction: trigger.trigger.triggerAction,
+                                            filter: { include: ((_d = trigger.trigger.filter) === null || _d === void 0 ? void 0 : _d.include) ? (_e = trigger.trigger.filter) === null || _e === void 0 ? void 0 : _e.include : CodeActionKind.QuickFix },
+                                            autoApply: trigger.trigger.autoApply,
+                                            context: { notAvailableMessage: ((_f = trigger.trigger.context) === null || _f === void 0 ? void 0 : _f.notAvailableMessage) || '', position: trackedPosition }
+                                        };
+                                        const selectionAsPosition = new Selection(trackedPosition.lineNumber, trackedPosition.column, trackedPosition.lineNumber, trackedPosition.column);
+                                        const actionsAtMarker = await getCodeActions(this._registry, model, selectionAsPosition, newCodeActionTrigger, Progress.None, token);
+                                        if (actionsAtMarker.validActions.length !== 0) {
+                                            for (const action of actionsAtMarker.validActions) {
+                                                action.highlightRange = action.action.isPreferred;
+                                            }
+                                            if (codeActionSet.allActions.length === 0) {
+                                                allCodeActions.push(...actionsAtMarker.allActions);
+                                            }
+                                            // Already filtered through to only get quickfixes, so no need to filter again.
+                                            if (Math.abs(currPosition.column - col) < distance) {
+                                                currentActions.unshift(...actionsAtMarker.validActions);
+                                            }
+                                            else {
+                                                currentActions.push(...actionsAtMarker.validActions);
+                                            }
+                                        }
+                                        distance = Math.abs(currPosition.column - col);
+                                    }
+                                }
+                                const filteredActions = currentActions.filter((action, index, self) => self.findIndex((a) => a.action.title === action.action.title) === index);
+                                filteredActions.sort((a, b) => {
+                                    if (a.action.isPreferred && !b.action.isPreferred) {
+                                        return -1;
+                                    }
+                                    else if (!a.action.isPreferred && b.action.isPreferred) {
+                                        return 1;
+                                    }
+                                    else if (a.action.isAI && !b.action.isAI) {
+                                        return 1;
+                                    }
+                                    else if (!a.action.isAI && b.action.isAI) {
+                                        return -1;
+                                    }
+                                    else {
+                                        return 0;
+                                    }
+                                });
+                                // Only retriggers if actually found quickfix on the same line as cursor
+                                return { validActions: filteredActions, allActions: allCodeActions, documentation: codeActionSet.documentation, hasAutoFix: codeActionSet.hasAutoFix, hasAIFix: codeActionSet.hasAIFix, allAIFixes: codeActionSet.allAIFixes, dispose: () => { codeActionSet.dispose(); } };
+                            }
+                        }
+                    }
+                    // temporarilly hiding here as this is enabled/disabled behind a setting.
+                    return getCodeActions(this._registry, model, trigger.selection, trigger.trigger, Progress.None, token);
+                });
+                if (trigger.trigger.type === 1 /* CodeActionTriggerType.Invoke */) {
+                    (_a = this._progressService) === null || _a === void 0 ? void 0 : _a.showWhile(actions, 250);
+                }
+                this.setState(new CodeActionsState.Triggered(trigger.trigger, startPosition, actions));
+            }, undefined);
+            this._codeActionOracle.value.trigger({ type: 2 /* CodeActionTriggerType.Auto */, triggerAction: CodeActionTriggerSource.Default });
+        }
+        else {
+            this._supportedCodeActions.reset();
+        }
+    }
+    trigger(trigger) {
+        var _a;
+        (_a = this._codeActionOracle.value) === null || _a === void 0 ? void 0 : _a.trigger(trigger);
+    }
+    setState(newState, skipNotify) {
+        if (newState === this._state) {
+            return;
+        }
+        // Cancel old request
+        if (this._state.type === 1 /* CodeActionsState.Type.Triggered */) {
+            this._state.cancel();
+        }
+        this._state = newState;
+        if (!skipNotify && !this._disposed) {
+            this._onDidChangeState.fire(newState);
+        }
+    }
+}

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/contrib/codelens/browser/codeLensCache.js

@@ -0,0 +1,112 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Event } from '../../../../base/common/event.js';
+import { LRUCache } from '../../../../base/common/map.js';
+import { Range } from '../../../common/core/range.js';
+import { CodeLensModel } from './codelens.js';
+import { registerSingleton } from '../../../../platform/instantiation/common/extensions.js';
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+import { IStorageService, WillSaveStateReason } from '../../../../platform/storage/common/storage.js';
+import { mainWindow } from '../../../../base/browser/window.js';
+import { runWhenWindowIdle } from '../../../../base/browser/dom.js';
+export const ICodeLensCache = createDecorator('ICodeLensCache');
+class CacheItem {
+    constructor(lineCount, data) {
+        this.lineCount = lineCount;
+        this.data = data;
+    }
+}
+let CodeLensCache = class CodeLensCache {
+    constructor(storageService) {
+        this._fakeProvider = new class {
+            provideCodeLenses() {
+                throw new Error('not supported');
+            }
+        };
+        this._cache = new LRUCache(20, 0.75);
+        // remove old data
+        const oldkey = 'codelens/cache';
+        runWhenWindowIdle(mainWindow, () => storageService.remove(oldkey, 1 /* StorageScope.WORKSPACE */));
+        // restore lens data on start
+        const key = 'codelens/cache2';
+        const raw = storageService.get(key, 1 /* StorageScope.WORKSPACE */, '{}');
+        this._deserialize(raw);
+        // store lens data on shutdown
+        Event.once(storageService.onWillSaveState)(e => {
+            if (e.reason === WillSaveStateReason.SHUTDOWN) {
+                storageService.store(key, this._serialize(), 1 /* StorageScope.WORKSPACE */, 1 /* StorageTarget.MACHINE */);
+            }
+        });
+    }
+    put(model, data) {
+        // create a copy of the model that is without command-ids
+        // but with comand-labels
+        const copyItems = data.lenses.map(item => {
+            var _a;
+            return {
+                range: item.symbol.range,
+                command: item.symbol.command && { id: '', title: (_a = item.symbol.command) === null || _a === void 0 ? void 0 : _a.title },
+            };
+        });
+        const copyModel = new CodeLensModel();
+        copyModel.add({ lenses: copyItems, dispose: () => { } }, this._fakeProvider);
+        const item = new CacheItem(model.getLineCount(), copyModel);
+        this._cache.set(model.uri.toString(), item);
+    }
+    get(model) {
+        const item = this._cache.get(model.uri.toString());
+        return item && item.lineCount === model.getLineCount() ? item.data : undefined;
+    }
+    delete(model) {
+        this._cache.delete(model.uri.toString());
+    }
+    // --- persistence
+    _serialize() {
+        const data = Object.create(null);
+        for (const [key, value] of this._cache) {
+            const lines = new Set();
+            for (const d of value.data.lenses) {
+                lines.add(d.symbol.range.startLineNumber);
+            }
+            data[key] = {
+                lineCount: value.lineCount,
+                lines: [...lines.values()]
+            };
+        }
+        return JSON.stringify(data);
+    }
+    _deserialize(raw) {
+        try {
+            const data = JSON.parse(raw);
+            for (const key in data) {
+                const element = data[key];
+                const lenses = [];
+                for (const line of element.lines) {
+                    lenses.push({ range: new Range(line, 1, line, 11) });
+                }
+                const model = new CodeLensModel();
+                model.add({ lenses, dispose() { } }, this._fakeProvider);
+                this._cache.set(key, new CacheItem(element.lineCount, model));
+            }
+        }
+        catch (_a) {
+            // ignore...
+        }
+    }
+};
+CodeLensCache = __decorate([
+    __param(0, IStorageService)
+], CodeLensCache);
+export { CodeLensCache };
+registerSingleton(ICodeLensCache, CodeLensCache, 1 /* InstantiationType.Delayed */);

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/editor/contrib/codelens/browser/codelens.js

@@ -0,0 +1,104 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { illegalArgument, onUnexpectedExternalError } from '../../../../base/common/errors.js';
+import { DisposableStore } from '../../../../base/common/lifecycle.js';
+import { assertType } from '../../../../base/common/types.js';
+import { URI } from '../../../../base/common/uri.js';
+import { IModelService } from '../../../common/services/model.js';
+import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
+import { ILanguageFeaturesService } from '../../../common/services/languageFeatures.js';
+export class CodeLensModel {
+    constructor() {
+        this.lenses = [];
+        this._disposables = new DisposableStore();
+    }
+    dispose() {
+        this._disposables.dispose();
+    }
+    get isDisposed() {
+        return this._disposables.isDisposed;
+    }
+    add(list, provider) {
+        this._disposables.add(list);
+        for (const symbol of list.lenses) {
+            this.lenses.push({ symbol, provider });
+        }
+    }
+}
+export async function getCodeLensModel(registry, model, token) {
+    const provider = registry.ordered(model);
+    const providerRanks = new Map();
+    const result = new CodeLensModel();
+    const promises = provider.map(async (provider, i) => {
+        providerRanks.set(provider, i);
+        try {
+            const list = await Promise.resolve(provider.provideCodeLenses(model, token));
+            if (list) {
+                result.add(list, provider);
+            }
+        }
+        catch (err) {
+            onUnexpectedExternalError(err);
+        }
+    });
+    await Promise.all(promises);
+    result.lenses = result.lenses.sort((a, b) => {
+        // sort by lineNumber, provider-rank, and column
+        if (a.symbol.range.startLineNumber < b.symbol.range.startLineNumber) {
+            return -1;
+        }
+        else if (a.symbol.range.startLineNumber > b.symbol.range.startLineNumber) {
+            return 1;
+        }
+        else if ((providerRanks.get(a.provider)) < (providerRanks.get(b.provider))) {
+            return -1;
+        }
+        else if ((providerRanks.get(a.provider)) > (providerRanks.get(b.provider))) {
+            return 1;
+        }
+        else if (a.symbol.range.startColumn < b.symbol.range.startColumn) {
+            return -1;
+        }
+        else if (a.symbol.range.startColumn > b.symbol.range.startColumn) {
+            return 1;
+        }
+        else {
+            return 0;
+        }
+    });
+    return result;
+}
+CommandsRegistry.registerCommand('_executeCodeLensProvider', function (accessor, ...args) {
+    let [uri, itemResolveCount] = args;
+    assertType(URI.isUri(uri));
+    assertType(typeof itemResolveCount === 'number' || !itemResolveCount);
+    const { codeLensProvider } = accessor.get(ILanguageFeaturesService);
+    const model = accessor.get(IModelService).getModel(uri);
+    if (!model) {
+        throw illegalArgument();
+    }
+    const result = [];
+    const disposables = new DisposableStore();
+    return getCodeLensModel(codeLensProvider, model, CancellationToken.None).then(value => {
+        disposables.add(value);
+        const resolve = [];
+        for (const item of value.lenses) {
+            if (itemResolveCount === undefined || itemResolveCount === null || Boolean(item.symbol.command)) {
+                result.push(item.symbol);
+            }
+            else if (itemResolveCount-- > 0 && item.provider.resolveCodeLens) {
+                resolve.push(Promise.resolve(item.provider.resolveCodeLens(model, item.symbol, CancellationToken.None)).then(symbol => result.push(symbol || item.symbol)));
+            }
+        }
+        return Promise.all(resolve);
+    }).then(() => {
+        return result;
+    }).finally(() => {
+        // make sure to return results, then (on next tick)
+        // dispose the results
+        setTimeout(() => disposables.dispose(), 100);
+    });
+});