claude-flow-novice 2.0.4 → 2.0.5

package/dist/src/validators/todowrite-batching-validator.js

@@ -1,215 +0,0 @@
-/**
- * TodoWrite Batching Validator
- *
- * Detects and warns about TodoWrite anti-patterns where multiple small calls
- * are made instead of a single batched call with 5-10+ items.
- *
- * Anti-pattern example (bad):
- *   TodoWrite([{...}])  // Call 1: 1 item
- *   TodoWrite([{...}])  // Call 2: 1 item
- *   TodoWrite([{...}])  // Call 3: 1 item
- *
- * Best practice (good):
- *   TodoWrite([{...}, {...}, {...}, {...}, {...}])  // Single call: 5+ items
- *
- * @module validators/todowrite-batching-validator
- */ function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-/**
- * Validates TodoWrite call patterns to ensure proper batching behavior
- *
- * Tracks call frequency within a sliding time window and detects anti-patterns
- * where multiple small calls are made instead of a single batched call.
- *
- * @example
- * ```typescript
- * const validator = new TodoWriteValidator({ strictMode: false });
- *
- * // Good: Single batched call
- * validator.validateBatching([
- *   { content: "Task 1", status: "pending", activeForm: "Doing task 1" },
- *   { content: "Task 2", status: "pending", activeForm: "Doing task 2" },
- *   { content: "Task 3", status: "pending", activeForm: "Doing task 3" },
- *   { content: "Task 4", status: "pending", activeForm: "Doing task 4" },
- *   { content: "Task 5", status: "pending", activeForm: "Doing task 5" }
- * ]); // ✅ No warning
- *
- * // Bad: Multiple small calls
- * validator.validateBatching([{ content: "Task 1", status: "pending", activeForm: "Doing task 1" }]);
- * validator.validateBatching([{ content: "Task 2", status: "pending", activeForm: "Doing task 2" }]);
- * // ⚠️ Warning: Batching anti-pattern detected
- * ```
- */ export class TodoWriteValidator {
-    /**
-   * Validates a TodoWrite call and checks for batching anti-patterns
-   *
-   * @param todos - Array of todos being written
-   * @throws Error if strictMode is enabled and anti-pattern detected
-   * @returns ValidationResult with detailed analysis
-   */ validateBatching(todos) {
-        const now = Date.now();
-        this.totalCallCount++;
-        // Log this call
-        this.callLog.push({
-            timestamp: now,
-            count: todos.length,
-            callIndex: this.totalCallCount
-        });
-        // Clean old entries outside time window
-        this.callLog = this.callLog.filter((entry)=>now - entry.timestamp < this.config.timeWindowMs);
-        // Calculate statistics
-        const totalItems = this.callLog.reduce((sum, entry)=>sum + entry.count, 0);
-        const averageItemsPerCall = totalItems / this.callLog.length;
-        const warnings = [];
-        const recommendations = [];
-        let isValid = true;
-        // Check for anti-pattern: too many calls in time window
-        if (this.callLog.length >= this.config.callThreshold) {
-            isValid = false;
-            const warningMessage = this.buildWarningMessage(totalItems, averageItemsPerCall);
-            warnings.push(warningMessage);
-            // Generate specific recommendations
-            recommendations.push(`Batch ALL todos in SINGLE TodoWrite call with ${this.config.minRecommendedItems}+ items`);
-            recommendations.push(`See CLAUDE.md: "TodoWrite batching requirement" and "1 MESSAGE = ALL RELATED OPERATIONS"`);
-            recommendations.push(`Example: TodoWrite([todo1, todo2, todo3, todo4, todo5]) instead of multiple calls`);
-            if (this.config.verbose) {
-                console.log("\n📊 TodoWrite Call Statistics:");
-                console.log(`   Total calls in window: ${this.callLog.length}`);
-                console.log(`   Total items: ${totalItems}`);
-                console.log(`   Average items per call: ${averageItemsPerCall.toFixed(2)}`);
-                console.log(`   Time window: ${this.config.timeWindowMs / 1000}s`);
-            }
-            // In strict mode, throw error
-            if (this.config.strictMode) {
-                throw new Error(`TodoWrite Batching Violation: ${warningMessage}\n\n` + `Recommendations:\n${recommendations.map((r)=>`  - ${r}`).join("\n")}`);
-            }
-            // Otherwise, log warning
-            console.warn(warningMessage);
-        }
-        // Additional check: warn if single call has too few items (informational only)
-        if (todos.length < this.config.minRecommendedItems && this.callLog.length === 1) {
-            recommendations.push(`Consider adding more todos to this batch (current: ${todos.length}, recommended: ${this.config.minRecommendedItems}+)`);
-        }
-        return {
-            isValid,
-            callCount: this.callLog.length,
-            totalItems,
-            averageItemsPerCall,
-            warnings,
-            recommendations
-        };
-    }
-    /**
-   * Builds a detailed warning message for batching anti-patterns
-   * @private
-   */ buildWarningMessage(totalItems, averageItemsPerCall) {
-        const timeWindowMinutes = this.config.timeWindowMs / 60000;
-        return `
-⚠️ TODOWRITE BATCHING ANTI-PATTERN DETECTED
-
-You have made ${this.callLog.length} TodoWrite calls in the last ${timeWindowMinutes} minutes.
-
-Best Practice: Batch ALL todos in SINGLE TodoWrite call with ${this.config.minRecommendedItems}-10+ items.
-
-Current calls (within ${timeWindowMinutes}min window):
-${this.callLog.map((entry, i)=>`  ${i + 1}. Call #${entry.callIndex}: ${entry.count} item${entry.count !== 1 ? "s" : ""} (${this.formatTimestamp(entry.timestamp)})`).join("\n")}
-
-Statistics:
-  - Total calls: ${this.callLog.length}
-  - Total items: ${totalItems}
-  - Average items per call: ${averageItemsPerCall.toFixed(2)}
-  - Recommended: 1 call with ${this.config.minRecommendedItems}+ items
-
-Impact:
-  - Multiple calls waste API resources
-  - Harder to track task relationships
-  - Violates "1 MESSAGE = ALL RELATED OPERATIONS" principle
-
-See CLAUDE.md: "TodoWrite batching requirement"
-    `.trim();
-    }
-    /**
-   * Formats timestamp for display in warning messages
-   * @private
-   */ formatTimestamp(timestamp) {
-        const secondsAgo = Math.floor((Date.now() - timestamp) / 1000);
-        if (secondsAgo < 60) return `${secondsAgo}s ago`;
-        const minutesAgo = Math.floor(secondsAgo / 60);
-        return `${minutesAgo}m ago`;
-    }
-    /**
-   * Gets current validation statistics
-   */ getStatistics() {
-        return {
-            totalCalls: this.totalCallCount,
-            callsInWindow: this.callLog.length,
-            timeWindowMs: this.config.timeWindowMs,
-            threshold: this.config.callThreshold
-        };
-    }
-    /**
-   * Resets the validator state (useful for testing)
-   */ reset() {
-        this.callLog = [];
-        this.totalCallCount = 0;
-    }
-    /**
-   * Updates validator configuration
-   */ updateConfig(config) {
-        this.config = {
-            ...this.config,
-            ...config
-        };
-    }
-    /**
-   * Checks if validation is currently passing (no anti-patterns detected)
-   */ isCurrentlyValid() {
-        return this.callLog.length < this.config.callThreshold;
-    }
-    constructor(config = {}){
-        _define_property(this, "callLog", []);
-        _define_property(this, "totalCallCount", 0);
-        _define_property(this, "config", void 0);
-        this.config = {
-            timeWindowMs: config.timeWindowMs ?? 300000,
-            callThreshold: config.callThreshold ?? 2,
-            strictMode: config.strictMode ?? false,
-            minRecommendedItems: config.minRecommendedItems ?? 5,
-            verbose: config.verbose ?? false
-        };
-    }
-}
-/**
- * Global singleton instance for use across the application
- */ let globalValidator = null;
-/**
- * Gets the global TodoWrite validator instance
- * Creates one if it doesn't exist
- */ export function getGlobalValidator(config) {
-    if (!globalValidator) {
-        globalValidator = new TodoWriteValidator(config);
-    } else if (config) {
-        globalValidator.updateConfig(config);
-    }
-    return globalValidator;
-}
-/**
- * Resets the global validator instance
- * Useful for testing and cleanup
- */ export function resetGlobalValidator() {
-    if (globalValidator) {
-        globalValidator.reset();
-    }
-    globalValidator = null;
-}

package/dist/src/validators/todowrite-integration.js

@@ -1,187 +0,0 @@
-/**
- * TodoWrite Validator Integration
- *
- * Provides CLI flag support and tool integration for the TodoWrite batching validator.
- * Can be enabled via --validate-batching flag or VALIDATE_TODOWRITE_BATCHING env var.
- *
- * @module validators/todowrite-integration
- */ import { getGlobalValidator } from "./todowrite-batching-validator";
-/**
- * Environment variables for controlling validation
- */ const ENV_VALIDATE_BATCHING = "VALIDATE_TODOWRITE_BATCHING";
-const ENV_STRICT_MODE = "TODOWRITE_STRICT_MODE";
-const ENV_VERBOSE = "TODOWRITE_VERBOSE";
-/**
- * Checks if validation is enabled via environment or config
- */ export function isValidationEnabled(config) {
-    // Check environment variable first
-    if (process.env[ENV_VALIDATE_BATCHING] === "true") {
-        return true;
-    }
-    // Check config
-    return config?.enabled ?? false;
-}
-/**
- * Gets integration config from environment and explicit config
- */ export function getIntegrationConfig(explicitConfig) {
-    return {
-        enabled: isValidationEnabled(explicitConfig),
-        strictMode: process.env[ENV_STRICT_MODE] === "true" || explicitConfig?.strictMode,
-        verbose: process.env[ENV_VERBOSE] === "true" || explicitConfig?.verbose,
-        timeWindowMs: explicitConfig?.timeWindowMs,
-        callThreshold: explicitConfig?.callThreshold,
-        minRecommendedItems: explicitConfig?.minRecommendedItems
-    };
-}
-/**
- * Validates a TodoWrite call with integrated configuration
- *
- * @param todos - Array of todos being written
- * @param config - Optional configuration override
- * @returns Validation result if enabled, null if disabled
- */ export function validateTodoWrite(todos, config) {
-    const integrationConfig = getIntegrationConfig(config);
-    // Skip validation if not enabled
-    if (!integrationConfig.enabled) {
-        return null;
-    }
-    // Get global validator and update config
-    const validator = getGlobalValidator({
-        strictMode: integrationConfig.strictMode,
-        verbose: integrationConfig.verbose,
-        timeWindowMs: integrationConfig.timeWindowMs,
-        callThreshold: integrationConfig.callThreshold,
-        minRecommendedItems: integrationConfig.minRecommendedItems
-    });
-    // Validate and return result
-    return validator.validateBatching(todos);
-}
-/**
- * CLI argument parser for validation flags
- */ export function parseValidationFlags(args) {
-    const config = {
-        enabled: false,
-        strictMode: false,
-        verbose: false
-    };
-    for(let i = 0; i < args.length; i++){
-        const arg = args[i];
-        switch(arg){
-            case "--validate-batching":
-                config.enabled = true;
-                break;
-            case "--strict":
-            case "--strict-mode":
-                config.strictMode = true;
-                break;
-            case "--verbose":
-            case "-v":
-                config.verbose = true;
-                break;
-            case "--time-window":
-                config.timeWindowMs = parseInt(args[++i], 10);
-                break;
-            case "--threshold":
-                config.callThreshold = parseInt(args[++i], 10);
-                break;
-            case "--min-items":
-                config.minRecommendedItems = parseInt(args[++i], 10);
-                break;
-        }
-    }
-    return config;
-}
-/**
- * Helper to display usage information
- */ export function displayValidationHelp() {
-    console.log(`
-TodoWrite Batching Validator - Usage
-
-Detects anti-patterns where multiple small TodoWrite calls are made
-instead of a single batched call with 5-10+ items.
-
-CLI Flags:
-  --validate-batching         Enable TodoWrite batching validation
-  --strict, --strict-mode     Throw error on anti-pattern (default: warn)
-  --verbose, -v               Show detailed statistics
-  --time-window <ms>          Time window for detection (default: 300000 = 5min)
-  --threshold <count>         Number of calls before warning (default: 2)
-  --min-items <count>         Minimum recommended items (default: 5)
-
-Environment Variables:
-  VALIDATE_TODOWRITE_BATCHING=true    Enable validation globally
-  TODOWRITE_STRICT_MODE=true          Enable strict mode globally
-  TODOWRITE_VERBOSE=true              Enable verbose logging globally
-
-Examples:
-  # Enable validation with defaults
-  npx claude-flow-novice task --validate-batching
-
-  # Enable strict mode (throw error on anti-pattern)
-  npx claude-flow-novice task --validate-batching --strict
-
-  # Custom thresholds
-  npx claude-flow-novice task --validate-batching --threshold 3 --time-window 600000
-
-  # Via environment
-  export VALIDATE_TODOWRITE_BATCHING=true
-  npx claude-flow-novice task
-
-Best Practice:
-  Always batch ALL todos in SINGLE TodoWrite call with 5-10+ items.
-  See CLAUDE.md: "TodoWrite batching requirement"
-  `.trim());
-}
-/**
- * Example integration with TodoWrite tool
- * This function wraps the actual TodoWrite implementation
- */ export function todoWriteWithValidation(todos, config) {
-    // Validate first if enabled
-    const validationResult = validateTodoWrite(todos, config);
-    if (validationResult && !validationResult.isValid) {
-        console.warn("\n⚠️ TodoWrite Batching Issue Detected\n");
-        console.warn("Recommendations:");
-        validationResult.recommendations.forEach((rec, i)=>{
-            console.warn(`  ${i + 1}. ${rec}`);
-        });
-        console.warn("");
-    }
-    // Proceed with actual TodoWrite implementation
-    // (This would call the real TodoWrite tool)
-    // For now, just log what would be written
-    if (config?.verbose) {
-        console.log(`\n✅ Writing ${todos.length} todos...`);
-    }
-}
-/**
- * Express middleware for validation (if using HTTP API)
- */ export function createValidationMiddleware(config) {
-    return (req, res, next)=>{
-        if (req.body && Array.isArray(req.body.todos)) {
-            try {
-                validateTodoWrite(req.body.todos, config);
-            } catch (error) {
-                // In strict mode, validation errors become HTTP errors
-                if (config?.strictMode) {
-                    return res.status(400).json({
-                        error: "TodoWrite Batching Violation",
-                        message: error.message
-                    });
-                }
-            }
-        }
-        next();
-    };
-}
-/**
- * Integration status checker
- */ export function getValidationStatus() {
-    const config = getIntegrationConfig();
-    const validator = getGlobalValidator();
-    return {
-        enabled: config.enabled,
-        strictMode: config.strictMode ?? false,
-        verbose: config.verbose ?? false,
-        statistics: validator.getStatistics()
-    };
-}

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

@@ -1,23 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  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 { assertType } from '../../../../base/common/types.js';
-import { URI } from '../../../../base/common/uri.js';
-import { ITextModelService } from '../../../common/services/resolverService.js';
-import { IOutlineModelService } from './outlineModel.js';
-import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
-CommandsRegistry.registerCommand('_executeDocumentSymbolProvider', async function (accessor, ...args) {
-    const [resource] = args;
-    assertType(URI.isUri(resource));
-    const outlineService = accessor.get(IOutlineModelService);
-    const modelService = accessor.get(ITextModelService);
-    const reference = await modelService.createModelReference(resource);
-    try {
-        return (await outlineService.getOrCreate(reference.object.textEditorModel, CancellationToken.None)).getTopLevelSymbols();
-    }
-    finally {
-        reference.dispose();
-    }
-});

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

@@ -1,57 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-import { EditorAction, EditorCommand, registerEditorAction, registerEditorCommand, registerEditorContribution } from '../../../browser/editorExtensions.js';
-import { registerEditorFeature } from '../../../common/editorFeatures.js';
-import { CopyPasteController, changePasteTypeCommandId, pasteWidgetVisibleCtx } from './copyPasteController.js';
-import { DefaultPasteProvidersFeature } from './defaultProviders.js';
-import * as nls from '../../../../nls.js';
-registerEditorContribution(CopyPasteController.ID, CopyPasteController, 0 /* EditorContributionInstantiation.Eager */); // eager because it listens to events on the container dom node of the editor
-registerEditorFeature(DefaultPasteProvidersFeature);
-registerEditorCommand(new class extends EditorCommand {
-    constructor() {
-        super({
-            id: changePasteTypeCommandId,
-            precondition: pasteWidgetVisibleCtx,
-            kbOpts: {
-                weight: 100 /* KeybindingWeight.EditorContrib */,
-                primary: 2048 /* KeyMod.CtrlCmd */ | 89 /* KeyCode.Period */,
-            }
-        });
-    }
-    runEditorCommand(_accessor, editor, _args) {
-        var _a;
-        return (_a = CopyPasteController.get(editor)) === null || _a === void 0 ? void 0 : _a.changePasteType();
-    }
-});
-registerEditorAction(class extends EditorAction {
-    constructor() {
-        super({
-            id: 'editor.action.pasteAs',
-            label: nls.localize('pasteAs', "Paste As..."),
-            alias: 'Paste As...',
-            precondition: undefined,
-            metadata: {
-                description: 'Paste as',
-                args: [{
-                        name: 'args',
-                        schema: {
-                            type: 'object',
-                            properties: {
-                                'id': {
-                                    type: 'string',
-                                    description: nls.localize('pasteAs.id', "The id of the paste edit to try applying. If not provided, the editor will show a picker."),
-                                }
-                            },
-                        }
-                    }]
-            }
-        });
-    }
-    run(_accessor, editor, args) {
-        var _a;
-        const id = typeof (args === null || args === void 0 ? void 0 : args.id) === 'string' ? args.id : undefined;
-        return (_a = CopyPasteController.get(editor)) === null || _a === void 0 ? void 0 : _a.pasteAs(id);
-    }
-});