monomind 1.6.1 → 1.6.3

package/packages/@monomind/cli/dist/src/types.d.ts

@@ -0,0 +1,198 @@
+/**
+ * CLI Type Definitions
+ * Modernized type system for the Monomind CLI
+ */
+export interface CommandContext {
+    args: string[];
+    flags: ParsedFlags;
+    config?: MonomindConfig;
+    cwd: string;
+    interactive: boolean;
+}
+export interface ParsedFlags {
+    [key: string]: string | boolean | number | string[];
+    _: string[];
+}
+export interface Command {
+    name: string;
+    description: string;
+    aliases?: string[];
+    subcommands?: Command[];
+    options?: CommandOption[];
+    examples?: CommandExample[];
+    action?: CommandAction;
+    hidden?: boolean;
+}
+export interface CommandOption {
+    name: string;
+    short?: string;
+    description: string;
+    type: 'string' | 'boolean' | 'number' | 'array';
+    default?: unknown;
+    required?: boolean;
+    choices?: string[];
+    validate?: (value: unknown) => boolean | string;
+}
+export interface CommandExample {
+    command: string;
+    description: string;
+}
+export type CommandAction = (ctx: CommandContext) => Promise<CommandResult | void>;
+export interface CommandResult {
+    success: boolean;
+    message?: string;
+    data?: unknown;
+    exitCode?: number;
+}
+export interface MonomindConfig {
+    version: string;
+    projectRoot: string;
+    agents: AgentConfig;
+    swarm: SwarmConfig;
+    memory: MemoryConfig;
+    mcp: MCPConfig;
+    cli: CLIPreferences;
+    hooks: HooksConfig;
+}
+export interface AgentConfig {
+    defaultType: string;
+    autoSpawn: boolean;
+    maxConcurrent: number;
+    timeout: number;
+    providers: ProviderConfig[];
+}
+export interface ProviderConfig {
+    name: string;
+    apiKey?: string;
+    baseUrl?: string;
+    model?: string;
+    priority: number;
+    enabled: boolean;
+}
+export interface SwarmConfig {
+    topology: 'hierarchical' | 'mesh' | 'ring' | 'star' | 'hybrid' | 'hierarchical-mesh';
+    maxAgents: number;
+    autoScale: boolean;
+    coordinationStrategy: 'consensus' | 'leader' | 'distributed';
+    healthCheckInterval: number;
+}
+export interface MemoryConfig {
+    backend: 'agentdb' | 'sqlite' | 'memory' | 'hybrid';
+    persistPath: string;
+    cacheSize: number;
+    enableHNSW: boolean;
+    vectorDimension: number;
+}
+export interface MCPConfig {
+    serverHost: string;
+    serverPort: number;
+    autoStart: boolean;
+    transportType: 'stdio' | 'http' | 'websocket';
+    tools: string[];
+}
+export interface CLIPreferences {
+    colorOutput: boolean;
+    interactive: boolean;
+    verbosity: 'quiet' | 'normal' | 'verbose' | 'debug';
+    outputFormat: 'text' | 'json' | 'table';
+    progressStyle: 'bar' | 'spinner' | 'dots' | 'none';
+}
+export interface HooksConfig {
+    enabled: boolean;
+    autoExecute: boolean;
+    hooks: HookDefinition[];
+}
+export interface HookDefinition {
+    name: string;
+    event: string;
+    handler: string;
+    priority: number;
+    enabled: boolean;
+}
+export interface TableColumn {
+    key: string;
+    header: string;
+    width?: number;
+    align?: 'left' | 'center' | 'right';
+    format?: (value: unknown) => string;
+}
+export interface TableOptions {
+    columns: TableColumn[];
+    data: Record<string, unknown>[];
+    border?: boolean;
+    header?: boolean;
+    padding?: number;
+    maxWidth?: number;
+}
+export interface ProgressOptions {
+    total: number;
+    current?: number;
+    width?: number;
+    format?: string;
+    showPercentage?: boolean;
+    showETA?: boolean;
+    showSpeed?: boolean;
+}
+export interface SpinnerOptions {
+    text: string;
+    spinner?: 'dots' | 'line' | 'arc' | 'circle' | 'arrows';
+    color?: string;
+}
+export interface SelectOption<T = string> {
+    value: T;
+    label: string;
+    hint?: string;
+    disabled?: boolean;
+    /** For multiselect: whether this option is selected by default */
+    selected?: boolean;
+}
+export interface SelectPromptOptions<T = string> {
+    message: string;
+    options: SelectOption<T>[];
+    default?: T;
+    searchable?: boolean;
+    pageSize?: number;
+}
+export interface ConfirmPromptOptions {
+    message: string;
+    default?: boolean;
+    active?: string;
+    inactive?: string;
+}
+export interface InputPromptOptions {
+    message: string;
+    default?: string;
+    placeholder?: string;
+    validate?: (value: string) => boolean | string;
+    mask?: boolean;
+}
+export interface MultiSelectPromptOptions<T = string> {
+    message: string;
+    options: SelectOption<T>[];
+    default?: T[];
+    required?: boolean;
+    min?: number;
+    max?: number;
+}
+export type CLIEventType = 'command:start' | 'command:end' | 'command:error' | 'prompt:start' | 'prompt:complete' | 'output:write' | 'progress:update' | 'spinner:start' | 'spinner:stop';
+export interface CLIEvent {
+    type: CLIEventType;
+    timestamp: number;
+    data?: unknown;
+}
+export declare class CLIError extends Error {
+    code: string;
+    exitCode: number;
+    details?: unknown | undefined;
+    constructor(message: string, code: string, exitCode?: number, details?: unknown | undefined);
+}
+export declare class ValidationError extends CLIError {
+    constructor(message: string, details?: unknown);
+}
+export declare class ConfigError extends CLIError {
+    constructor(message: string, details?: unknown);
+}
+export declare class CommandNotFoundError extends CLIError {
+    constructor(commandName: string);
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/@monomind/cli/dist/src/types.js

@@ -0,0 +1,38 @@
+/**
+ * CLI Type Definitions
+ * Modernized type system for the Monomind CLI
+ */
+// ============================================
+// Error Types
+// ============================================
+export class CLIError extends Error {
+    code;
+    exitCode;
+    details;
+    constructor(message, code, exitCode = 1, details) {
+        super(message);
+        this.code = code;
+        this.exitCode = exitCode;
+        this.details = details;
+        this.name = 'CLIError';
+    }
+}
+export class ValidationError extends CLIError {
+    constructor(message, details) {
+        super(message, 'VALIDATION_ERROR', 1, details);
+        this.name = 'ValidationError';
+    }
+}
+export class ConfigError extends CLIError {
+    constructor(message, details) {
+        super(message, 'CONFIG_ERROR', 1, details);
+        this.name = 'ConfigError';
+    }
+}
+export class CommandNotFoundError extends CLIError {
+    constructor(commandName) {
+        super(`Unknown command: ${commandName}`, 'COMMAND_NOT_FOUND', 127);
+        this.name = 'CommandNotFoundError';
+    }
+}
+//# sourceMappingURL=types.js.map

package/packages/@monomind/cli/dist/src/update/checker.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Update checker for @monoes packages
+ * Queries npm registry and compares versions
+ */
+export interface UpdateCheckResult {
+    package: string;
+    currentVersion: string;
+    latestVersion: string;
+    updateType: 'major' | 'minor' | 'patch' | 'none';
+    shouldAutoUpdate: boolean;
+    priority: 'critical' | 'high' | 'normal' | 'low';
+    changelog?: string;
+}
+export interface UpdateConfig {
+    enabled: boolean;
+    checkIntervalHours: number;
+    autoUpdate: {
+        patch: boolean;
+        minor: boolean;
+        major: boolean;
+    };
+    priority: Record<string, 'critical' | 'high' | 'normal' | 'low'>;
+    exclude: string[];
+}
+declare const DEFAULT_CONFIG: UpdateConfig;
+export declare function getInstalledVersion(packageName: string): string | null;
+export declare function checkForUpdates(config?: UpdateConfig): Promise<{
+    results: UpdateCheckResult[];
+    skipped: boolean;
+    reason?: string;
+}>;
+export declare function checkSinglePackage(packageName: string, config?: UpdateConfig): Promise<UpdateCheckResult | null>;
+export { DEFAULT_CONFIG };
+//# sourceMappingURL=checker.d.ts.map

package/packages/@monomind/cli/dist/src/update/checker.js

@@ -0,0 +1,185 @@
+/**
+ * Update checker for @monomind packages
+ * Queries npm registry and compares versions
+ */
+import * as semver from 'semver';
+import { shouldCheckForUpdates, recordCheck, getCachedVersions } from './rate-limiter.js';
+const DEFAULT_CONFIG = {
+    enabled: true,
+    checkIntervalHours: 24,
+    autoUpdate: {
+        patch: true,
+        minor: false,
+        major: false,
+    },
+    priority: {
+        '@monomind/security': 'critical',
+        '@monomind/cli': 'high',
+        '@monomind/embeddings': 'normal',
+    },
+    exclude: [],
+};
+// Packages to check for updates
+const MONOMIND_PACKAGES = [
+    'monomind',
+    '@monomind/cli',
+];
+async function fetchPackageInfo(packageName) {
+    try {
+        const response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(packageName)}`, {
+            headers: { Accept: 'application/json' },
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!response.ok) {
+            return null;
+        }
+        return (await response.json());
+    }
+    catch {
+        return null;
+    }
+}
+function getUpdateType(current, latest) {
+    if (!semver.valid(current) || !semver.valid(latest)) {
+        return 'none';
+    }
+    if (semver.eq(current, latest)) {
+        return 'none';
+    }
+    if (semver.major(latest) > semver.major(current)) {
+        return 'major';
+    }
+    if (semver.minor(latest) > semver.minor(current)) {
+        return 'minor';
+    }
+    if (semver.patch(latest) > semver.patch(current)) {
+        return 'patch';
+    }
+    return 'none';
+}
+function shouldAutoUpdate(updateType, priority, config) {
+    if (updateType === 'none')
+        return false;
+    // Critical security packages always auto-update patches
+    if (priority === 'critical' && updateType === 'patch') {
+        return true;
+    }
+    // Check config
+    if (updateType === 'major')
+        return config.autoUpdate.major;
+    if (updateType === 'minor')
+        return config.autoUpdate.minor;
+    if (updateType === 'patch')
+        return config.autoUpdate.patch;
+    return false;
+}
+export function getInstalledVersion(packageName) {
+    try {
+        // Try to find the package in node_modules
+        const possiblePaths = [
+            `${packageName}/package.json`,
+            `../../node_modules/${packageName}/package.json`,
+            `../../../node_modules/${packageName}/package.json`,
+        ];
+        for (const modulePath of possiblePaths) {
+            try {
+                // Use dynamic import with require for package.json
+                const resolved = require.resolve(modulePath, { paths: [process.cwd()] });
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const pkg = require(resolved);
+                return pkg.version;
+            }
+            catch {
+                continue;
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function checkForUpdates(config = DEFAULT_CONFIG) {
+    // Check rate limit
+    const rateCheck = shouldCheckForUpdates(config.checkIntervalHours);
+    if (!rateCheck.allowed) {
+        // Return cached results if available
+        const cached = getCachedVersions();
+        if (Object.keys(cached).length > 0) {
+            return {
+                results: [],
+                skipped: true,
+                reason: rateCheck.reason,
+            };
+        }
+        return { results: [], skipped: true, reason: rateCheck.reason };
+    }
+    const results = [];
+    const versionCache = {};
+    // Check each package
+    const packagesToCheck = MONOMIND_PACKAGES.filter((pkg) => !config.exclude.includes(pkg));
+    // Sort by priority (critical first)
+    const priorityOrder = { critical: 0, high: 1, normal: 2, low: 3 };
+    packagesToCheck.sort((a, b) => {
+        const pa = config.priority[a] || 'normal';
+        const pb = config.priority[b] || 'normal';
+        return priorityOrder[pa] - priorityOrder[pb];
+    });
+    await Promise.all(packagesToCheck.map(async (packageName) => {
+        const currentVersion = getInstalledVersion(packageName);
+        if (!currentVersion) {
+            // Package not installed, skip
+            return;
+        }
+        const info = await fetchPackageInfo(packageName);
+        if (!info) {
+            return;
+        }
+        const latestVersion = info['dist-tags']?.latest;
+        if (!latestVersion) {
+            return;
+        }
+        versionCache[packageName] = latestVersion;
+        const updateType = getUpdateType(currentVersion, latestVersion);
+        const priority = config.priority[packageName] || 'normal';
+        results.push({
+            package: packageName,
+            currentVersion,
+            latestVersion,
+            updateType,
+            priority,
+            shouldAutoUpdate: shouldAutoUpdate(updateType, priority, config),
+        });
+    }));
+    // Record this check
+    recordCheck(versionCache);
+    // Filter to only updates available
+    const updates = results.filter((r) => r.updateType !== 'none');
+    return { results: updates, skipped: false };
+}
+export async function checkSinglePackage(packageName, config = DEFAULT_CONFIG) {
+    const currentVersion = getInstalledVersion(packageName);
+    if (!currentVersion) {
+        return null;
+    }
+    const info = await fetchPackageInfo(packageName);
+    if (!info) {
+        return null;
+    }
+    const latestVersion = info['dist-tags']?.latest;
+    if (!latestVersion) {
+        return null;
+    }
+    const updateType = getUpdateType(currentVersion, latestVersion);
+    const priority = config.priority[packageName] || 'normal';
+    return {
+        package: packageName,
+        currentVersion,
+        latestVersion,
+        updateType,
+        priority,
+        shouldAutoUpdate: shouldAutoUpdate(updateType, priority, config),
+    };
+}
+export { DEFAULT_CONFIG };
+//# sourceMappingURL=checker.js.map

package/packages/@monomind/cli/dist/src/update/executor.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Update executor - performs actual package updates
+ * Includes rollback capability
+ */
+import { UpdateCheckResult } from './checker.js';
+import { ValidationResult } from './validator.js';
+export interface UpdateHistoryEntry {
+    timestamp: string;
+    package: string;
+    fromVersion: string;
+    toVersion: string;
+    success: boolean;
+    error?: string;
+    rollbackAvailable: boolean;
+}
+export interface UpdateExecutionResult {
+    success: boolean;
+    package: string;
+    version: string;
+    error?: string;
+    validation: ValidationResult;
+}
+export declare function loadHistory(): UpdateHistoryEntry[];
+export declare function executeUpdate(update: UpdateCheckResult, installedPackages: Record<string, string>, dryRun?: boolean): Promise<UpdateExecutionResult>;
+export declare function executeMultipleUpdates(updates: UpdateCheckResult[], installedPackages: Record<string, string>, dryRun?: boolean): Promise<UpdateExecutionResult[]>;
+export declare function rollbackUpdate(packageName?: string): Promise<{
+    success: boolean;
+    message: string;
+}>;
+export declare function getUpdateHistory(limit?: number): UpdateHistoryEntry[];
+export declare function clearHistory(): void;
+//# sourceMappingURL=executor.d.ts.map

package/packages/@monomind/cli/dist/src/update/executor.js

@@ -0,0 +1,181 @@
+/**
+ * Update executor - performs actual package updates
+ * Includes rollback capability
+ */
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { validateUpdate } from './validator.js';
+const HISTORY_FILE = path.join(os.homedir(), '.monomind', 'update-history.json');
+const MAX_HISTORY_ENTRIES = 100;
+function ensureDir() {
+    const dir = path.dirname(HISTORY_FILE);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+export function loadHistory() {
+    try {
+        if (fs.existsSync(HISTORY_FILE)) {
+            const content = fs.readFileSync(HISTORY_FILE, 'utf-8');
+            return JSON.parse(content);
+        }
+    }
+    catch {
+        // Corrupted file
+    }
+    return [];
+}
+function saveHistory(history) {
+    ensureDir();
+    // Keep only last N entries
+    const trimmed = history.slice(-MAX_HISTORY_ENTRIES);
+    fs.writeFileSync(HISTORY_FILE, JSON.stringify(trimmed, null, 2));
+}
+function recordUpdate(entry) {
+    const history = loadHistory();
+    history.push(entry);
+    saveHistory(history);
+}
+export async function executeUpdate(update, installedPackages, dryRun = false) {
+    // Validate first
+    const validation = validateUpdate(update.package, update.currentVersion, update.latestVersion, installedPackages);
+    if (!validation.valid) {
+        return {
+            success: false,
+            package: update.package,
+            version: update.latestVersion,
+            error: `Validation failed: ${validation.incompatibilities.join(', ')}`,
+            validation,
+        };
+    }
+    if (dryRun) {
+        return {
+            success: true,
+            package: update.package,
+            version: update.latestVersion,
+            validation,
+        };
+    }
+    try {
+        // Execute npm install
+        const installCmd = `npm install ${update.package}@${update.latestVersion} --save-exact`;
+        execSync(installCmd, {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            timeout: 60000, // 1 minute timeout
+        });
+        // Record successful update
+        recordUpdate({
+            timestamp: new Date().toISOString(),
+            package: update.package,
+            fromVersion: update.currentVersion,
+            toVersion: update.latestVersion,
+            success: true,
+            rollbackAvailable: true,
+        });
+        return {
+            success: true,
+            package: update.package,
+            version: update.latestVersion,
+            validation,
+        };
+    }
+    catch (error) {
+        const err = error;
+        // Record failed update
+        recordUpdate({
+            timestamp: new Date().toISOString(),
+            package: update.package,
+            fromVersion: update.currentVersion,
+            toVersion: update.latestVersion,
+            success: false,
+            error: err.message,
+            rollbackAvailable: false,
+        });
+        return {
+            success: false,
+            package: update.package,
+            version: update.latestVersion,
+            error: err.message,
+            validation,
+        };
+    }
+}
+export async function executeMultipleUpdates(updates, installedPackages, dryRun = false) {
+    const results = [];
+    // Execute updates sequentially to avoid conflicts
+    for (const update of updates) {
+        const result = await executeUpdate(update, installedPackages, dryRun);
+        results.push(result);
+        // Update installed packages for next validation
+        if (result.success) {
+            installedPackages[update.package] = update.latestVersion;
+        }
+        // Stop on critical failures
+        if (!result.success && update.priority === 'critical') {
+            break;
+        }
+    }
+    return results;
+}
+export async function rollbackUpdate(packageName) {
+    const history = loadHistory();
+    if (history.length === 0) {
+        return { success: false, message: 'No update history available' };
+    }
+    // Find the last successful update for this package (or any if not specified)
+    const lastUpdate = packageName
+        ? history
+            .reverse()
+            .find((h) => h.package === packageName && h.success && h.rollbackAvailable)
+        : history.reverse().find((h) => h.success && h.rollbackAvailable);
+    if (!lastUpdate) {
+        return {
+            success: false,
+            message: packageName
+                ? `No rollback available for ${packageName}`
+                : 'No rollback available',
+        };
+    }
+    try {
+        // Install the previous version
+        const installCmd = `npm install ${lastUpdate.package}@${lastUpdate.fromVersion} --save-exact`;
+        execSync(installCmd, {
+            encoding: 'utf-8',
+            stdio: 'pipe',
+            timeout: 60000,
+        });
+        // Record the rollback
+        recordUpdate({
+            timestamp: new Date().toISOString(),
+            package: lastUpdate.package,
+            fromVersion: lastUpdate.toVersion,
+            toVersion: lastUpdate.fromVersion,
+            success: true,
+            rollbackAvailable: false, // Can't rollback a rollback
+        });
+        return {
+            success: true,
+            message: `Rolled back ${lastUpdate.package} from ${lastUpdate.toVersion} to ${lastUpdate.fromVersion}`,
+        };
+    }
+    catch (error) {
+        const err = error;
+        return {
+            success: false,
+            message: `Rollback failed: ${err.message}`,
+        };
+    }
+}
+export function getUpdateHistory(limit = 20) {
+    const history = loadHistory();
+    return history.slice(-limit).reverse();
+}
+export function clearHistory() {
+    if (fs.existsSync(HISTORY_FILE)) {
+        fs.unlinkSync(HISTORY_FILE);
+    }
+}
+//# sourceMappingURL=executor.js.map

package/packages/@monomind/cli/dist/src/update/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Auto-update system for @monoes 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