@cloudpftc/opencode-orchestrator 3.5.15

package/v3/@claude-flow/cli/dist/src/update/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Auto-update system for @claude-flow packages
+ *
+ * Features:
+ * - Rate-limited update checks (24h default)
+ * - Automatic patch updates for security packages
+ * - Compatibility validation before updates
+ * - Rollback capability
+ * - Update history logging
+ */
+export { checkForUpdates, checkSinglePackage, getInstalledVersion, DEFAULT_CONFIG, } from './checker.js';
+export type { UpdateCheckResult, UpdateConfig } from './checker.js';
+export { shouldCheckForUpdates, recordCheck, getCachedVersions, clearCache, loadState, } from './rate-limiter.js';
+export type { RateLimitState } from './rate-limiter.js';
+export { validateUpdate, validateBulkUpdate } from './validator.js';
+export type { ValidationResult } from './validator.js';
+export { executeUpdate, executeMultipleUpdates, rollbackUpdate, getUpdateHistory, clearHistory, loadHistory, } from './executor.js';
+export type { UpdateHistoryEntry, UpdateExecutionResult } from './executor.js';
+import type { UpdateCheckResult } from './checker.js';
+/**
+ * Run auto-update check on startup
+ * This is the main entry point for the auto-update system
+ */
+export declare function runStartupUpdateCheck(options: {
+    verbose?: boolean;
+    autoUpdate?: boolean;
+}): Promise<{
+    checked: boolean;
+    updatesAvailable: UpdateCheckResult[];
+    updatesApplied: string[];
+    skippedReason?: string;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/v3/@claude-flow/cli/dist/src/update/index.js

@@ -0,0 +1,64 @@
+/**
+ * Auto-update system for @claude-flow packages
+ *
+ * Features:
+ * - Rate-limited update checks (24h default)
+ * - Automatic patch updates for security packages
+ * - Compatibility validation before updates
+ * - Rollback capability
+ * - Update history logging
+ */
+export { checkForUpdates, checkSinglePackage, getInstalledVersion, DEFAULT_CONFIG, } from './checker.js';
+export { shouldCheckForUpdates, recordCheck, getCachedVersions, clearCache, loadState, } from './rate-limiter.js';
+export { validateUpdate, validateBulkUpdate } from './validator.js';
+export { executeUpdate, executeMultipleUpdates, rollbackUpdate, getUpdateHistory, clearHistory, loadHistory, } from './executor.js';
+// Re-export a convenience function for startup
+import { checkForUpdates, DEFAULT_CONFIG } from './checker.js';
+import { executeMultipleUpdates } from './executor.js';
+import { getInstalledVersion } from './checker.js';
+/**
+ * Run auto-update check on startup
+ * This is the main entry point for the auto-update system
+ */
+export async function runStartupUpdateCheck(options) {
+    const result = {
+        checked: false,
+        updatesAvailable: [],
+        updatesApplied: [],
+        skippedReason: undefined,
+    };
+    try {
+        const { results, skipped, reason } = await checkForUpdates(DEFAULT_CONFIG);
+        if (skipped) {
+            result.skippedReason = reason;
+            return result;
+        }
+        result.checked = true;
+        result.updatesAvailable = results;
+        // Auto-update if enabled
+        if (options.autoUpdate !== false) {
+            const autoUpdateable = results.filter((r) => r.shouldAutoUpdate);
+            if (autoUpdateable.length > 0) {
+                // Get current installed packages
+                const installedPackages = {};
+                for (const update of autoUpdateable) {
+                    const version = getInstalledVersion(update.package);
+                    if (version) {
+                        installedPackages[update.package] = version;
+                    }
+                }
+                // Execute updates
+                const updateResults = await executeMultipleUpdates(autoUpdateable, installedPackages);
+                result.updatesApplied = updateResults
+                    .filter((r) => r.success)
+                    .map((r) => `${r.package}@${r.version}`);
+            }
+        }
+        return result;
+    }
+    catch {
+        // Silently fail on startup - don't block CLI usage
+        return result;
+    }
+}
+//# sourceMappingURL=index.js.map

package/v3/@claude-flow/cli/dist/src/update/rate-limiter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Rate limiter for update checks
+ * Prevents excessive npm registry queries
+ */
+export interface RateLimitState {
+    lastCheck: string;
+    checksToday: number;
+    date: string;
+    packageVersions: Record<string, string>;
+}
+export declare function loadState(): RateLimitState;
+export declare function saveState(state: RateLimitState): void;
+export declare function shouldCheckForUpdates(intervalHours?: number): {
+    allowed: boolean;
+    reason?: string;
+};
+export declare function recordCheck(packageVersions: Record<string, string>): void;
+export declare function getCachedVersions(): Record<string, string>;
+export declare function clearCache(): void;
+//# sourceMappingURL=rate-limiter.d.ts.map

package/v3/@claude-flow/cli/dist/src/update/rate-limiter.js

@@ -0,0 +1,96 @@
+/**
+ * Rate limiter for update checks
+ * Prevents excessive npm registry queries
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+const STATE_FILE = path.join(os.homedir(), '.claude-flow', 'update-state.json');
+const DEFAULT_INTERVAL_HOURS = 24;
+const MAX_CHECKS_PER_DAY = 10;
+function ensureDir() {
+    const dir = path.dirname(STATE_FILE);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+function getDefaultState() {
+    return {
+        lastCheck: '',
+        checksToday: 0,
+        date: new Date().toISOString().split('T')[0],
+        packageVersions: {},
+    };
+}
+export function loadState() {
+    try {
+        if (fs.existsSync(STATE_FILE)) {
+            const content = fs.readFileSync(STATE_FILE, 'utf-8');
+            const state = JSON.parse(content);
+            // Reset counter if new day
+            const today = new Date().toISOString().split('T')[0];
+            if (state.date !== today) {
+                state.date = today;
+                state.checksToday = 0;
+            }
+            return state;
+        }
+    }
+    catch {
+        // Corrupted file, reset
+    }
+    return getDefaultState();
+}
+export function saveState(state) {
+    ensureDir();
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+export function shouldCheckForUpdates(intervalHours = DEFAULT_INTERVAL_HOURS) {
+    // Skip in CI environments
+    if (process.env.CI === 'true' || process.env.CONTINUOUS_INTEGRATION === 'true') {
+        return { allowed: false, reason: 'CI environment detected' };
+    }
+    // Skip if explicitly disabled
+    if (process.env.CLAUDE_FLOW_AUTO_UPDATE === 'false') {
+        return { allowed: false, reason: 'Auto-update disabled via environment' };
+    }
+    // Force update if requested
+    if (process.env.CLAUDE_FLOW_FORCE_UPDATE === 'true') {
+        return { allowed: true };
+    }
+    const state = loadState();
+    // Check daily limit
+    if (state.checksToday >= MAX_CHECKS_PER_DAY) {
+        return { allowed: false, reason: `Daily check limit (${MAX_CHECKS_PER_DAY}) reached` };
+    }
+    // Check time interval
+    if (state.lastCheck) {
+        const lastCheckTime = new Date(state.lastCheck).getTime();
+        const now = Date.now();
+        const hoursSinceLastCheck = (now - lastCheckTime) / (1000 * 60 * 60);
+        if (hoursSinceLastCheck < intervalHours) {
+            const nextCheck = Math.ceil(intervalHours - hoursSinceLastCheck);
+            return {
+                allowed: false,
+                reason: `Last check was ${Math.floor(hoursSinceLastCheck)}h ago (next check in ~${nextCheck}h)`
+            };
+        }
+    }
+    return { allowed: true };
+}
+export function recordCheck(packageVersions) {
+    const state = loadState();
+    state.lastCheck = new Date().toISOString();
+    state.checksToday += 1;
+    state.packageVersions = { ...state.packageVersions, ...packageVersions };
+    saveState(state);
+}
+export function getCachedVersions() {
+    return loadState().packageVersions;
+}
+export function clearCache() {
+    if (fs.existsSync(STATE_FILE)) {
+        fs.unlinkSync(STATE_FILE);
+    }
+}
+//# sourceMappingURL=rate-limiter.js.map

package/v3/@claude-flow/cli/dist/src/update/validator.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Package validator for update compatibility
+ * Ensures updates don't break the ecosystem
+ */
+export interface ValidationResult {
+    valid: boolean;
+    incompatibilities: string[];
+    warnings: string[];
+    requiredPeerUpdates: string[];
+}
+export declare function validateUpdate(packageName: string, fromVersion: string, toVersion: string, installedPackages: Record<string, string>): ValidationResult;
+export declare function validateBulkUpdate(updates: Array<{
+    package: string;
+    from: string;
+    to: string;
+}>, currentPackages: Record<string, string>): ValidationResult;
+//# sourceMappingURL=validator.d.ts.map

package/v3/@claude-flow/cli/dist/src/update/validator.js

@@ -0,0 +1,123 @@
+/**
+ * Package validator for update compatibility
+ * Ensures updates don't break the ecosystem
+ */
+import * as semver from 'semver';
+// Known compatibility matrix between @claude-flow packages
+const COMPATIBILITY_MATRIX = {
+    '@claude-flow/cli': {
+        '@claude-flow/embeddings': { minVersion: '3.0.0-alpha.1' },
+        '@claude-flow/security': { minVersion: '3.0.0-alpha.1' },
+        '@claude-flow/integration': { minVersion: '3.0.0-alpha.1' },
+    },
+    '@claude-flow/embeddings': {
+        '@claude-flow/cli': { minVersion: '3.0.0-alpha.50' },
+    },
+    '@claude-flow/integration': {
+        '@claude-flow/cli': { minVersion: '3.0.0-alpha.70' },
+        'agentic-flow': { minVersion: '3.0.0-alpha.1' },
+    },
+};
+// Known breaking changes by version
+const BREAKING_CHANGES = {
+    '@claude-flow/cli': {
+        '3.0.0': [
+            'Memory API changed from key-value to vector-based',
+            'Hooks system completely redesigned',
+            'Agent spawning now requires type parameter',
+        ],
+    },
+    '@claude-flow/embeddings': {
+        '3.0.0': [
+            'Switched from better-sqlite3 to sql.js',
+            'New initialization required with initEmbeddings()',
+        ],
+    },
+};
+export function validateUpdate(packageName, fromVersion, toVersion, installedPackages) {
+    const result = {
+        valid: true,
+        incompatibilities: [],
+        warnings: [],
+        requiredPeerUpdates: [],
+    };
+    // Check if this is a major version bump
+    if (semver.valid(fromVersion) && semver.valid(toVersion)) {
+        const fromMajor = semver.major(fromVersion);
+        const toMajor = semver.major(toVersion);
+        if (toMajor > fromMajor) {
+            result.warnings.push(`Major version update (${fromMajor} → ${toMajor}) may contain breaking changes`);
+            // Check for known breaking changes
+            const changes = BREAKING_CHANGES[packageName]?.[`${toMajor}.0.0`];
+            if (changes) {
+                result.warnings.push(`Known breaking changes in v${toMajor}:`);
+                changes.forEach((change) => result.warnings.push(`  - ${change}`));
+            }
+        }
+    }
+    // Check compatibility with installed packages
+    const compatibility = COMPATIBILITY_MATRIX[packageName];
+    if (compatibility) {
+        for (const [depName, depReq] of Object.entries(compatibility)) {
+            const installedVersion = installedPackages[depName];
+            if (installedVersion) {
+                // Check minimum version
+                if (semver.valid(installedVersion) &&
+                    semver.lt(installedVersion, depReq.minVersion)) {
+                    result.incompatibilities.push(`${packageName}@${toVersion} requires ${depName} >= ${depReq.minVersion} (installed: ${installedVersion})`);
+                    result.requiredPeerUpdates.push(`${depName}@>=${depReq.minVersion}`);
+                    result.valid = false;
+                }
+                // Check maximum version
+                if (depReq.maxVersion &&
+                    semver.valid(installedVersion) &&
+                    semver.gt(installedVersion, depReq.maxVersion)) {
+                    result.warnings.push(`${packageName}@${toVersion} may not be compatible with ${depName}@${installedVersion} (max: ${depReq.maxVersion})`);
+                }
+            }
+        }
+    }
+    // Check reverse compatibility - other packages that depend on this one
+    for (const [pkgName, deps] of Object.entries(COMPATIBILITY_MATRIX)) {
+        if (pkgName === packageName)
+            continue;
+        const depInfo = deps[packageName];
+        if (depInfo && installedPackages[pkgName]) {
+            // If the target version is below what the installed package needs
+            if (semver.valid(toVersion) && semver.lt(toVersion, depInfo.minVersion)) {
+                result.incompatibilities.push(`${pkgName}@${installedPackages[pkgName]} requires ${packageName} >= ${depInfo.minVersion}`);
+                result.valid = false;
+            }
+        }
+    }
+    return result;
+}
+export function validateBulkUpdate(updates, currentPackages) {
+    const combinedResult = {
+        valid: true,
+        incompatibilities: [],
+        warnings: [],
+        requiredPeerUpdates: [],
+    };
+    // Create a simulated state after all updates
+    const simulatedPackages = { ...currentPackages };
+    for (const update of updates) {
+        simulatedPackages[update.package] = update.to;
+    }
+    // Validate each update against the final state
+    for (const update of updates) {
+        const result = validateUpdate(update.package, update.from, update.to, simulatedPackages);
+        if (!result.valid) {
+            combinedResult.valid = false;
+        }
+        combinedResult.incompatibilities.push(...result.incompatibilities);
+        combinedResult.warnings.push(...result.warnings);
+        combinedResult.requiredPeerUpdates.push(...result.requiredPeerUpdates);
+    }
+    // Deduplicate
+    combinedResult.incompatibilities = [...new Set(combinedResult.incompatibilities)];
+    combinedResult.warnings = [...new Set(combinedResult.warnings)];
+    combinedResult.requiredPeerUpdates = [...new Set(combinedResult.requiredPeerUpdates)];
+    return combinedResult;
+}
+//# sourceMappingURL=validator.js.map

package/v3/@claude-flow/cli/package.json

@@ -0,0 +1,108 @@
+{
+  "name": "@opencode-orchestrator/cli",
+  "version": "3.5.15",
+  "type": "module",
+  "description": "OpenCode Orchestrator CLI - Enterprise AI agent orchestration with 60+ specialized agents, swarm coordination, MCP server, self-learning hooks, and vector memory",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "sideEffects": false,
+  "bin": {
+    "cli": "./bin/cli.js",
+    "opencode-orchestrator": "./bin/cli.js",
+    "opencode": "./bin/cli.js"
+  },
+  "homepage": "https://github.com/ruvnet/claude-flow#readme",
+  "bugs": {
+    "url": "https://github.com/ruvnet/claude-flow/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ruvnet/claude-flow.git",
+    "directory": "v3/@claude-flow/cli"
+  },
+  "keywords": [
+    "claude",
+    "anthropic",
+    "ai-agents",
+    "multi-agent",
+    "swarm",
+    "mcp",
+    "model-context-protocol",
+    "llm",
+    "cli",
+    "orchestration",
+    "automation",
+    "developer-tools",
+    "coding-assistant",
+    "vector-database",
+    "embeddings",
+    "self-learning",
+    "enterprise"
+  ],
+  "author": {
+    "name": "RuvNet",
+    "email": "ruv@ruv.io",
+    "url": "https://ruv.io"
+  },
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/src/index.js"
+    },
+    "./ruvector": {
+      "types": "./dist/src/ruvector/index.d.ts",
+      "import": "./dist/src/ruvector/index.js"
+    },
+    "./ruvector/*": {
+      "types": "./dist/src/ruvector/*.d.ts",
+      "import": "./dist/src/ruvector/*.js"
+    },
+    "./mcp-tools": {
+      "types": "./dist/src/mcp-tools/index.d.ts",
+      "import": "./dist/src/mcp-tools/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "bin",
+    ".claude",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:plugin-store": "npx tsx src/plugins/tests/standalone-test.ts",
+    "test:pattern-store": "npx tsx src/transfer/store/tests/standalone-test.ts",
+    "preinstall": "node bin/preinstall.cjs || true",
+    "prepublishOnly": "cp ../../../README.md ./README.md",
+    "release": "npm version prerelease --preid=alpha && npm run publish:all",
+    "publish:all": "./scripts/publish.sh"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "vitest": "^4.0.16"
+  },
+  "dependencies": {
+    "@claude-flow/mcp": "^3.0.0-alpha.8",
+    "@claude-flow/shared": "^3.0.0-alpha.1",
+    "@noble/ed25519": "^2.1.0",
+    "semver": "^7.6.0"
+  },
+  "optionalDependencies": {
+    "@claude-flow/aidefence": "^3.0.2",
+    "@claude-flow/embeddings": "^3.0.0-alpha.12",
+    "@claude-flow/guidance": "^3.0.0-alpha.1",
+    "@claude-flow/memory": "^3.0.0-alpha.11",
+    "@claude-flow/plugin-gastown-bridge": "^0.1.3",
+    "agentic-flow": "^3.0.0-alpha.1",
+    "@ruvector/attention": "^0.1.4",
+    "@ruvector/learning-wasm": "^0.1.29",
+    "@ruvector/router": "^0.1.27",
+    "@ruvector/sona": "^0.1.5"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  }
+}