claude-flow-novice 2.2.3 → 2.2.5

package/dist/scripts/verify-sdk-phase1.cjs

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+
+/**
+ * SDK Phase 1 Verification Script
+ *
+ * Verifies that Phase 1 implementation is complete and functional
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+console.log('\n' + '='.repeat(70));
+console.log('🔍 CLAUDE AGENT SDK - PHASE 1 VERIFICATION');
+console.log('='.repeat(70) + '\n');
+
+let allPassed = true;
+const results = [];
+
+function check(name, condition, details = '') {
+  const passed = condition;
+  results.push({ name, passed, details });
+
+  if (passed) {
+    console.log(`✅ ${name}`);
+    if (details) console.log(`   ${details}`);
+  } else {
+    console.log(`❌ ${name}`);
+    if (details) console.log(`   ${details}`);
+    allPassed = false;
+  }
+}
+
+// 1. Check package installation
+console.log('\n📦 CHECKING PACKAGE INSTALLATION\n');
+
+try {
+  const packageJson = require('../package.json');
+  check(
+    'Package.json exists',
+    true,
+    'Located at root directory'
+  );
+
+  check(
+    '@anthropic-ai/claude-agent-sdk installed',
+    packageJson.dependencies['@anthropic-ai/claude-agent-sdk'] !== undefined,
+    `Version: ${packageJson.dependencies['@anthropic-ai/claude-agent-sdk']}`
+  );
+} catch (error) {
+  check('Package.json readable', false, error.message);
+}
+
+// 2. Check SDK files
+console.log('\n📂 CHECKING SDK FILES\n');
+
+const requiredFiles = [
+  { path: 'src/sdk/config.cjs', desc: 'SDK configuration' },
+  { path: 'src/sdk/monitor.cjs', desc: 'Token usage monitoring' },
+  { path: 'src/sdk/index.cjs', desc: 'Main integration layer' }
+];
+
+requiredFiles.forEach(({ path: filePath, desc }) => {
+  const fullPath = path.join(__dirname, '..', filePath);
+  const exists = fs.existsSync(fullPath);
+  const size = exists ? fs.statSync(fullPath).size : 0;
+
+  check(
+    `${filePath} exists`,
+    exists,
+    `${desc} - ${(size / 1024).toFixed(1)} KB`
+  );
+});
+
+// 3. Check test files
+console.log('\n🧪 CHECKING TEST FILES\n');
+
+const testFile = path.join(__dirname, '../tests/sdk-integration.test.js');
+check(
+  'tests/sdk-integration.test.js exists',
+  fs.existsSync(testFile),
+  'Phase 1 test suite'
+);
+
+// 4. Check documentation
+console.log('\n📚 CHECKING DOCUMENTATION\n');
+
+const docFiles = [
+  'docs/sdk-integration-phase1.md',
+  'docs/sdk-phase1-summary.md'
+];
+
+docFiles.forEach((docFile) => {
+  const fullPath = path.join(__dirname, '..', docFile);
+  const exists = fs.existsSync(fullPath);
+
+  check(
+    `${docFile} exists`,
+    exists,
+    exists ? `${(fs.statSync(fullPath).size / 1024).toFixed(1)} KB` : ''
+  );
+});
+
+// 5. Check environment configuration
+console.log('\n⚙️  CHECKING ENVIRONMENT CONFIGURATION\n');
+
+const envFile = path.join(__dirname, '../.env');
+if (fs.existsSync(envFile)) {
+  const envContent = fs.readFileSync(envFile, 'utf-8');
+
+  const envVars = [
+    'ENABLE_SDK_CACHING',
+    'ENABLE_CONTEXT_EDITING',
+    'SDK_INTEGRATION_MODE',
+    'ENABLE_SDK_INTEGRATION'
+  ];
+
+  envVars.forEach((varName) => {
+    check(
+      `${varName} in .env`,
+      envContent.includes(varName),
+      `Environment variable configured`
+    );
+  });
+} else {
+  check('.env file exists', false, 'Environment file not found');
+}
+
+// 6. Test SDK loading
+console.log('\n🔧 TESTING SDK LOADING\n');
+
+try {
+  const sdk = require('../src/sdk/index.cjs');
+
+  check(
+    'SDK module loads',
+    true,
+    'No syntax errors'
+  );
+
+  check(
+    'SDK exports initialize',
+    typeof sdk.initialize === 'function',
+    'Initialize function available'
+  );
+
+  check(
+    'SDK exports monitoring',
+    typeof sdk.getMonitor === 'function',
+    'Monitoring functions available'
+  );
+
+  check(
+    'SDK exports config',
+    typeof sdk.getSDKConfig === 'function',
+    'Configuration functions available'
+  );
+
+  check(
+    'TOKEN_COSTS defined',
+    sdk.TOKEN_COSTS !== undefined,
+    `Input: $${sdk.TOKEN_COSTS.input}, Cached: $${sdk.TOKEN_COSTS.cached}`
+  );
+} catch (error) {
+  check('SDK module loads', false, error.message);
+}
+
+// 7. Test monitor functionality
+console.log('\n📊 TESTING MONITOR FUNCTIONALITY\n');
+
+try {
+  const { SDKMonitor } = require('../src/sdk/index.cjs');
+
+  const monitor = new SDKMonitor({ persistMetrics: false });
+
+  check(
+    'Monitor instantiates',
+    monitor !== null,
+    'Monitor object created'
+  );
+
+  check(
+    'Monitor tracks metrics',
+    monitor.metrics !== undefined,
+    'Metrics object exists'
+  );
+
+  check(
+    'Monitor calculates savings',
+    typeof monitor.calculateSavings === 'function',
+    'Savings calculation available'
+  );
+
+  // Test savings calculation
+  const savings = monitor.calculateSavings(1000);
+  check(
+    'Savings calculation works',
+    savings > 0,
+    `1000 tokens → ${savings.toFixed(0)} saved`
+  );
+
+  // Test report generation
+  monitor.metrics.tokensBefore = 10000;
+  monitor.metrics.tokensAfter = 1000;
+  monitor.metrics.totalCostSaved = 0.027;
+  monitor.metrics.operations = 5;
+
+  const report = monitor.getSavingsReport();
+  check(
+    'Report generation works',
+    report.summary !== undefined,
+    `Operations: ${report.summary.operations}, Savings: ${report.summary.costSaved}`
+  );
+} catch (error) {
+  check('Monitor functionality', false, error.message);
+}
+
+// 8. Test configuration
+console.log('\n⚙️  TESTING CONFIGURATION\n');
+
+try {
+  const { getSDKConfig, isSDKEnabled } = require('../src/sdk/index.cjs');
+
+  const config = getSDKConfig();
+
+  check(
+    'Config loads',
+    config !== null,
+    'Configuration object returned'
+  );
+
+  check(
+    'Config has required fields',
+    config.caching !== undefined && config.contextEditing !== undefined,
+    `Caching: ${config.caching}, Context: ${config.contextEditing}`
+  );
+
+  // Test enable/disable
+  const originalMode = process.env.SDK_INTEGRATION_MODE;
+
+  process.env.SDK_INTEGRATION_MODE = 'parallel';
+  const enabledParallel = isSDKEnabled();
+
+  process.env.SDK_INTEGRATION_MODE = 'disabled';
+  const disabledMode = isSDKEnabled();
+
+  process.env.SDK_INTEGRATION_MODE = originalMode;
+
+  check(
+    'Enable/disable works',
+    enabledParallel === true && disabledMode === false,
+    'Integration mode control functional'
+  );
+} catch (error) {
+  check('Configuration', false, error.message);
+}
+
+// Summary
+console.log('\n' + '='.repeat(70));
+console.log('📋 VERIFICATION SUMMARY');
+console.log('='.repeat(70) + '\n');
+
+const passed = results.filter(r => r.passed).length;
+const total = results.length;
+const percentage = ((passed / total) * 100).toFixed(1);
+
+console.log(`Tests Passed: ${passed}/${total} (${percentage}%)`);
+
+if (allPassed) {
+  console.log('\n✅ PHASE 1 IMPLEMENTATION VERIFIED SUCCESSFULLY\n');
+  console.log('All components are in place and functional:');
+  console.log('  • SDK configuration with extended caching and context editing');
+  console.log('  • Token usage monitoring and cost tracking');
+  console.log('  • Integration layer with easy-to-use API');
+  console.log('  • Test suite for validation');
+  console.log('  • Comprehensive documentation');
+  console.log('  • Environment configuration');
+  console.log('\nNext steps:');
+  console.log('  1. Set CLAUDE_API_KEY in .env');
+  console.log('  2. Run: node src/sdk/index.cjs');
+  console.log('  3. Start using SDK with executeWithTracking()');
+  console.log('  4. Monitor savings with getSavingsReport()');
+} else {
+  console.log('\n⚠️  SOME VERIFICATIONS FAILED\n');
+  console.log('Please review the failed checks above and ensure:');
+  console.log('  • All files are created in correct locations');
+  console.log('  • Package dependencies are installed');
+  console.log('  • Environment variables are configured');
+  console.log('  • No syntax errors in SDK modules');
+}
+
+console.log('\n' + '='.repeat(70) + '\n');
+
+process.exit(allPassed ? 0 : 1);

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/clipboard/browser/clipboardService.js

@@ -0,0 +1,141 @@
+/*---------------------------------------------------------------------------------------------
+ *  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 { isSafari, isWebkitWebView } from '../../../base/browser/browser.js';
+import { $, addDisposableListener, getActiveDocument } from '../../../base/browser/dom.js';
+import { DeferredPromise } from '../../../base/common/async.js';
+import { Event } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { ILayoutService } from '../../layout/browser/layoutService.js';
+import { ILogService } from '../../log/common/log.js';
+let BrowserClipboardService = class BrowserClipboardService extends Disposable {
+    constructor(layoutService, logService) {
+        super();
+        this.layoutService = layoutService;
+        this.logService = logService;
+        this.mapTextToType = new Map(); // unsupported in web (only in-memory)
+        this.findText = ''; // unsupported in web (only in-memory)
+        this.resources = []; // unsupported in web (only in-memory)
+        if (isSafari || isWebkitWebView) {
+            this.installWebKitWriteTextWorkaround();
+        }
+    }
+    // In Safari, it has the following note:
+    //
+    // "The request to write to the clipboard must be triggered during a user gesture.
+    // A call to clipboard.write or clipboard.writeText outside the scope of a user
+    // gesture(such as "click" or "touch" event handlers) will result in the immediate
+    // rejection of the promise returned by the API call."
+    // From: https://webkit.org/blog/10855/async-clipboard-api/
+    //
+    // Since extensions run in a web worker, and handle gestures in an asynchronous way,
+    // they are not classified by Safari as "in response to a user gesture" and will reject.
+    //
+    // This function sets up some handlers to work around that behavior.
+    installWebKitWriteTextWorkaround() {
+        const handler = () => {
+            const currentWritePromise = new DeferredPromise();
+            // Cancel the previous promise since we just created a new one in response to this new event
+            if (this.webKitPendingClipboardWritePromise && !this.webKitPendingClipboardWritePromise.isSettled) {
+                this.webKitPendingClipboardWritePromise.cancel();
+            }
+            this.webKitPendingClipboardWritePromise = currentWritePromise;
+            // The ctor of ClipboardItem allows you to pass in a promise that will resolve to a string.
+            // This allows us to pass in a Promise that will either be cancelled by another event or
+            // resolved with the contents of the first call to this.writeText.
+            // see https://developer.mozilla.org/en-US/docs/Web/API/ClipboardItem/ClipboardItem#parameters
+            navigator.clipboard.write([new ClipboardItem({
+                    'text/plain': currentWritePromise.p,
+                })]).catch(async (err) => {
+                if (!(err instanceof Error) || err.name !== 'NotAllowedError' || !currentWritePromise.isRejected) {
+                    this.logService.error(err);
+                }
+            });
+        };
+        this._register(Event.runAndSubscribe(this.layoutService.onDidAddContainer, ({ container, disposables }) => {
+            disposables.add(addDisposableListener(container, 'click', handler));
+            disposables.add(addDisposableListener(container, 'keydown', handler));
+        }, { container: this.layoutService.mainContainer, disposables: this._store }));
+    }
+    async writeText(text, type) {
+        // With type: only in-memory is supported
+        if (type) {
+            this.mapTextToType.set(type, text);
+            return;
+        }
+        if (this.webKitPendingClipboardWritePromise) {
+            // For Safari, we complete this Promise which allows the call to `navigator.clipboard.write()`
+            // above to resolve and successfully copy to the clipboard. If we let this continue, Safari
+            // would throw an error because this call stack doesn't appear to originate from a user gesture.
+            return this.webKitPendingClipboardWritePromise.complete(text);
+        }
+        // Guard access to navigator.clipboard with try/catch
+        // as we have seen DOMExceptions in certain browsers
+        // due to security policies.
+        try {
+            return await navigator.clipboard.writeText(text);
+        }
+        catch (error) {
+            console.error(error);
+        }
+        // Fallback to textarea and execCommand solution
+        const activeDocument = getActiveDocument();
+        const activeElement = activeDocument.activeElement;
+        const textArea = activeDocument.body.appendChild($('textarea', { 'aria-hidden': true }));
+        textArea.style.height = '1px';
+        textArea.style.width = '1px';
+        textArea.style.position = 'absolute';
+        textArea.value = text;
+        textArea.focus();
+        textArea.select();
+        activeDocument.execCommand('copy');
+        if (activeElement instanceof HTMLElement) {
+            activeElement.focus();
+        }
+        activeDocument.body.removeChild(textArea);
+        return;
+    }
+    async readText(type) {
+        // With type: only in-memory is supported
+        if (type) {
+            return this.mapTextToType.get(type) || '';
+        }
+        // Guard access to navigator.clipboard with try/catch
+        // as we have seen DOMExceptions in certain browsers
+        // due to security policies.
+        try {
+            return await navigator.clipboard.readText();
+        }
+        catch (error) {
+            console.error(error);
+            return '';
+        }
+    }
+    async readFindText() {
+        return this.findText;
+    }
+    async writeFindText(text) {
+        this.findText = text;
+    }
+    async writeResources(resources) {
+        this.resources = resources;
+    }
+    async readResources() {
+        return this.resources;
+    }
+};
+BrowserClipboardService = __decorate([
+    __param(0, ILayoutService),
+    __param(1, ILogService)
+], BrowserClipboardService);
+export { BrowserClipboardService };

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/clipboard/common/clipboardService.js

@@ -0,0 +1,6 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+export const IClipboardService = createDecorator('clipboardService');

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/commands/common/commands.js

@@ -0,0 +1,80 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { Emitter } from '../../../base/common/event.js';
+import { Iterable } from '../../../base/common/iterator.js';
+import { toDisposable } from '../../../base/common/lifecycle.js';
+import { LinkedList } from '../../../base/common/linkedList.js';
+import { validateConstraints } from '../../../base/common/types.js';
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+export const ICommandService = createDecorator('commandService');
+export const CommandsRegistry = new class {
+    constructor() {
+        this._commands = new Map();
+        this._onDidRegisterCommand = new Emitter();
+        this.onDidRegisterCommand = this._onDidRegisterCommand.event;
+    }
+    registerCommand(idOrCommand, handler) {
+        if (!idOrCommand) {
+            throw new Error(`invalid command`);
+        }
+        if (typeof idOrCommand === 'string') {
+            if (!handler) {
+                throw new Error(`invalid command`);
+            }
+            return this.registerCommand({ id: idOrCommand, handler });
+        }
+        // add argument validation if rich command metadata is provided
+        if (idOrCommand.metadata && Array.isArray(idOrCommand.metadata.args)) {
+            const constraints = [];
+            for (const arg of idOrCommand.metadata.args) {
+                constraints.push(arg.constraint);
+            }
+            const actualHandler = idOrCommand.handler;
+            idOrCommand.handler = function (accessor, ...args) {
+                validateConstraints(args, constraints);
+                return actualHandler(accessor, ...args);
+            };
+        }
+        // find a place to store the command
+        const { id } = idOrCommand;
+        let commands = this._commands.get(id);
+        if (!commands) {
+            commands = new LinkedList();
+            this._commands.set(id, commands);
+        }
+        const removeFn = commands.unshift(idOrCommand);
+        const ret = toDisposable(() => {
+            removeFn();
+            const command = this._commands.get(id);
+            if (command === null || command === void 0 ? void 0 : command.isEmpty()) {
+                this._commands.delete(id);
+            }
+        });
+        // tell the world about this command
+        this._onDidRegisterCommand.fire(id);
+        return ret;
+    }
+    registerCommandAlias(oldId, newId) {
+        return CommandsRegistry.registerCommand(oldId, (accessor, ...args) => accessor.get(ICommandService).executeCommand(newId, ...args));
+    }
+    getCommand(id) {
+        const list = this._commands.get(id);
+        if (!list || list.isEmpty()) {
+            return undefined;
+        }
+        return Iterable.first(list);
+    }
+    getCommands() {
+        const result = new Map();
+        for (const key of this._commands.keys()) {
+            const command = this.getCommand(key);
+            if (command) {
+                result.set(key, command);
+            }
+        }
+        return result;
+    }
+};
+CommandsRegistry.registerCommand('noop', () => { });

package/dist/src/web/frontend/node_modules/.monaco-editor-MndU045b/esm/vs/platform/configuration/common/configuration.js

@@ -0,0 +1,86 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+export const IConfigurationService = createDecorator('configurationService');
+export function toValuesTree(properties, conflictReporter) {
+    const root = Object.create(null);
+    for (const key in properties) {
+        addToValueTree(root, key, properties[key], conflictReporter);
+    }
+    return root;
+}
+export function addToValueTree(settingsTreeRoot, key, value, conflictReporter) {
+    const segments = key.split('.');
+    const last = segments.pop();
+    let curr = settingsTreeRoot;
+    for (let i = 0; i < segments.length; i++) {
+        const s = segments[i];
+        let obj = curr[s];
+        switch (typeof obj) {
+            case 'undefined':
+                obj = curr[s] = Object.create(null);
+                break;
+            case 'object':
+                break;
+            default:
+                conflictReporter(`Ignoring ${key} as ${segments.slice(0, i + 1).join('.')} is ${JSON.stringify(obj)}`);
+                return;
+        }
+        curr = obj;
+    }
+    if (typeof curr === 'object' && curr !== null) {
+        try {
+            curr[last] = value; // workaround https://github.com/microsoft/vscode/issues/13606
+        }
+        catch (e) {
+            conflictReporter(`Ignoring ${key} as ${segments.join('.')} is ${JSON.stringify(curr)}`);
+        }
+    }
+    else {
+        conflictReporter(`Ignoring ${key} as ${segments.join('.')} is ${JSON.stringify(curr)}`);
+    }
+}
+export function removeFromValueTree(valueTree, key) {
+    const segments = key.split('.');
+    doRemoveFromValueTree(valueTree, segments);
+}
+function doRemoveFromValueTree(valueTree, segments) {
+    const first = segments.shift();
+    if (segments.length === 0) {
+        // Reached last segment
+        delete valueTree[first];
+        return;
+    }
+    if (Object.keys(valueTree).indexOf(first) !== -1) {
+        const value = valueTree[first];
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            doRemoveFromValueTree(value, segments);
+            if (Object.keys(value).length === 0) {
+                delete valueTree[first];
+            }
+        }
+    }
+}
+/**
+ * A helper function to get the configuration value with a specific settings path (e.g. config.some.setting)
+ */
+export function getConfigurationValue(config, settingPath, defaultValue) {
+    function accessSetting(config, path) {
+        let current = config;
+        for (const component of path) {
+            if (typeof current !== 'object' || current === null) {
+                return undefined;
+            }
+            current = current[component];
+        }
+        return current;
+    }
+    const path = settingPath.split('.');
+    const result = accessSetting(config, path);
+    return typeof result === 'undefined' ? defaultValue : result;
+}
+export function getLanguageTagSettingPlainKey(settingKey) {
+    return settingKey.replace(/[\[\]]/g, '');
+}