monomind 1.18.9 → 1.18.11

package/packages/@monomind/cli/dist/src/commands/monovector/status.d.ts

@@ -1,11 +0,0 @@
-/**
- * CLI MonoVector Status Command
- * Check connection and schema status
- */
-import type { Command } from '../../types.js';
-/**
- * MonoVector status command
- */
-export declare const statusCommand: Command;
-export default statusCommand;
-//# sourceMappingURL=status.d.ts.map

package/packages/@monomind/cli/dist/src/commands/monovector/status.js

@@ -1,491 +0,0 @@
-/**
- * CLI MonoVector Status Command
- * Check connection and schema status
- */
-import { output } from '../../output.js';
-/**
- * Get PostgreSQL connection config from context
- */
-function getConnectionConfig(ctx) {
-    return {
-        host: ctx.flags.host || process.env.PGHOST || 'localhost',
-        port: parseInt(ctx.flags.port || process.env.PGPORT || '5432', 10),
-        database: ctx.flags.database || process.env.PGDATABASE || '',
-        user: ctx.flags.user || process.env.PGUSER || 'postgres',
-        password: ctx.flags.password || process.env.PGPASSWORD || '',
-        ssl: ctx.flags.ssl || process.env.PGSSLMODE === 'require',
-        schema: ctx.flags.schema || 'monomind',
-    };
-}
-const IDENTIFIER_RE = /^[a-zA-Z_][a-zA-Z0-9_]{0,63}$/;
-function validateIdentifier(name, label) {
-    if (!IDENTIFIER_RE.test(name))
-        return `Invalid ${label}: "${name}" (must match [a-zA-Z_][a-zA-Z0-9_]{0,63})`;
-    return null;
-}
-/**
- * Format bytes to human readable
- */
-function formatBytes(bytes) {
-    if (bytes === 0)
-        return '0 B';
-    const k = 1024;
-    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
-    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
-}
-/**
- * MonoVector status command
- */
-export const statusCommand = {
-    name: 'status',
-    description: 'Check connection and schema status',
-    options: [
-        {
-            name: 'verbose',
-            short: 'v',
-            description: 'Show detailed information',
-            type: 'boolean',
-            default: false,
-        },
-        {
-            name: 'json',
-            description: 'Output as JSON',
-            type: 'boolean',
-            default: false,
-        },
-        {
-            name: 'host',
-            short: 'h',
-            description: 'PostgreSQL host',
-            type: 'string',
-            default: 'localhost',
-        },
-        {
-            name: 'port',
-            short: 'p',
-            description: 'PostgreSQL port',
-            type: 'number',
-            default: 5432,
-        },
-        {
-            name: 'database',
-            short: 'd',
-            description: 'Database name',
-            type: 'string',
-        },
-        {
-            name: 'user',
-            short: 'u',
-            description: 'Database user',
-            type: 'string',
-        },
-        {
-            name: 'password',
-            description: 'Database password',
-            type: 'string',
-        },
-        {
-            name: 'ssl',
-            description: 'Enable SSL',
-            type: 'boolean',
-            default: false,
-        },
-        {
-            name: 'schema',
-            short: 's',
-            description: 'Schema name',
-            type: 'string',
-            default: 'monomind',
-        },
-    ],
-    examples: [
-        { command: 'monomind monovector status', description: 'Check basic status' },
-        { command: 'monomind monovector status --verbose', description: 'Show detailed info' },
-        { command: 'monomind monovector status --json', description: 'Output as JSON' },
-    ],
-    action: async (ctx) => {
-        const config = getConnectionConfig(ctx);
-        const verbose = ctx.flags.verbose;
-        const jsonOutput = ctx.flags.json;
-        if (!jsonOutput) {
-            output.writeln();
-            output.writeln(output.bold('MonoVector PostgreSQL Status'));
-            output.writeln(output.dim('='.repeat(60)));
-            output.writeln();
-        }
-        if (!config.database) {
-            if (jsonOutput) {
-                output.printJson({ error: 'Database name required' });
-            }
-            else {
-                output.printError('Database name is required. Use --database or -d flag, or set PGDATABASE env.');
-            }
-            return { success: false, exitCode: 1 };
-        }
-        const schemaErr = validateIdentifier(config.schema, 'schema');
-        if (schemaErr) {
-            if (jsonOutput)
-                output.printJson({ error: schemaErr });
-            else
-                output.printError(schemaErr);
-            return { success: false, exitCode: 1 };
-        }
-        const statusData = {
-            connection: {},
-            pgvector: {},
-            monovector: {},
-            tables: [],
-            indexes: [],
-            migrations: [],
-        };
-        const spinner = output.createSpinner({ text: 'Connecting to PostgreSQL...', spinner: 'dots' });
-        if (!jsonOutput)
-            spinner.start();
-        try {
-            // Import pg
-            let pg = null;
-            try {
-                pg = await import('pg');
-            }
-            catch {
-                if (!jsonOutput)
-                    spinner.fail('PostgreSQL driver not found');
-                if (jsonOutput) {
-                    output.printJson({ error: 'pg package not installed' });
-                }
-                else {
-                    output.printError('Install pg package: npm install pg');
-                }
-                return { success: false, exitCode: 1 };
-            }
-            const startTime = Date.now();
-            const client = new pg.Client({
-                host: config.host,
-                port: config.port,
-                database: config.database,
-                user: config.user,
-                password: config.password,
-                ssl: config.ssl ? { rejectUnauthorized: false } : false,
-            });
-            await client.connect();
-            const connectionTime = Date.now() - startTime;
-            if (!jsonOutput)
-                spinner.succeed(`Connected in ${connectionTime}ms`);
-            statusData.connection = {
-                host: config.host,
-                port: config.port,
-                database: config.database,
-                user: config.user,
-                ssl: config.ssl,
-                latency: connectionTime,
-                status: 'connected',
-            };
-            // Get PostgreSQL version
-            const versionResult = await client.query('SELECT version()');
-            const pgVersion = versionResult.rows[0].version;
-            statusData.connection.pgVersion = pgVersion;
-            // Check vector extension: prefer monovector, fall back to pgvector
-            if (!jsonOutput)
-                spinner.setText('Checking vector extension...');
-            spinner.start();
-            // Check for monovector first
-            const monovectorResult = await client.query(`
-        SELECT extname, extversion FROM pg_extension WHERE extname = 'monovector'
-      `);
-            if (monovectorResult.rows.length > 0) {
-                statusData.pgvector = {
-                    installed: true,
-                    extensionName: 'monovector',
-                    version: monovectorResult.rows[0].extversion,
-                };
-                if (!jsonOutput) {
-                    spinner.succeed(`monovector v${monovectorResult.rows[0].extversion} installed`);
-                }
-            }
-            else {
-                // Fall back to pgvector
-                const pgvectorResult = await client.query(`
-          SELECT extname, extversion FROM pg_extension WHERE extname = 'vector'
-        `);
-                if (pgvectorResult.rows.length > 0) {
-                    statusData.pgvector = {
-                        installed: true,
-                        extensionName: 'vector',
-                        version: pgvectorResult.rows[0].extversion,
-                    };
-                    if (!jsonOutput) {
-                        spinner.succeed(`pgvector v${pgvectorResult.rows[0].extversion} installed`);
-                    }
-                }
-                else {
-                    statusData.pgvector = { installed: false };
-                    if (!jsonOutput) {
-                        spinner.succeed(output.warning('No vector extension installed (monovector or pgvector)'));
-                    }
-                }
-            }
-            // Check schema exists
-            if (!jsonOutput)
-                spinner.setText(`Checking schema "${config.schema}"...`);
-            spinner.start();
-            const schemaResult = await client.query(`
-        SELECT schema_name FROM information_schema.schemata WHERE schema_name = $1
-      `, [config.schema]);
-            if (schemaResult.rows.length === 0) {
-                statusData.monovector = { initialized: false };
-                if (!jsonOutput) {
-                    spinner.succeed(output.warning(`Schema "${config.schema}" not found`));
-                    output.printInfo('Run `monomind monovector init` to initialize');
-                }
-                if (jsonOutput) {
-                    output.printJson(statusData);
-                }
-                await client.end();
-                return { success: true, data: statusData };
-            }
-            if (!jsonOutput)
-                spinner.succeed(`Schema "${config.schema}" found`);
-            // Get MonoVector metadata
-            if (!jsonOutput)
-                spinner.setText('Loading MonoVector metadata...');
-            spinner.start();
-            try {
-                const metadataResult = await client.query(`
-          SELECT key, value FROM ${config.schema}.metadata
-        `);
-                const metadata = {};
-                for (const row of metadataResult.rows) {
-                    metadata[row.key] = JSON.parse(row.value);
-                }
-                statusData.monovector = {
-                    initialized: true,
-                    version: metadata.monovector_version || 'unknown',
-                    dimensions: metadata.dimensions || 1536,
-                    initializedAt: metadata.initialized_at,
-                };
-                if (!jsonOutput)
-                    spinner.succeed('MonoVector metadata loaded');
-            }
-            catch {
-                statusData.monovector = { initialized: true, version: 'unknown' };
-                if (!jsonOutput)
-                    spinner.succeed(output.warning('Could not load MonoVector metadata'));
-            }
-            // Get table statistics
-            if (!jsonOutput)
-                spinner.setText('Gathering table statistics...');
-            spinner.start();
-            const tablesResult = await client.query(`
-        SELECT
-          t.table_name,
-          pg_relation_size(quote_ident(t.table_schema) || '.' || quote_ident(t.table_name)) as table_size,
-          pg_total_relation_size(quote_ident(t.table_schema) || '.' || quote_ident(t.table_name)) as total_size,
-          (SELECT count(*) FROM ${config.schema}.embeddings) as row_count
-        FROM information_schema.tables t
-        WHERE t.table_schema = $1
-        ORDER BY t.table_name
-      `, [config.schema]);
-            const tableStats = [];
-            for (const row of tablesResult.rows) {
-                // Get row count for each table
-                let rowCount = 0;
-                try {
-                    const countResult = await client.query(`SELECT count(*) as cnt FROM ${config.schema}.` +
-                        `${String(row.table_name).replace(/[^a-zA-Z0-9_]/g, '')}`);
-                    rowCount = parseInt(countResult.rows[0].cnt, 10);
-                }
-                catch {
-                    // Skip if can't count
-                }
-                tableStats.push({
-                    name: row.table_name,
-                    rows: rowCount,
-                    size: formatBytes(parseInt(row.table_size, 10)),
-                    totalSize: formatBytes(parseInt(row.total_size, 10)),
-                });
-            }
-            statusData.tables = tableStats;
-            if (!jsonOutput)
-                spinner.succeed(`Found ${tableStats.length} tables`);
-            // Get index information
-            if (verbose) {
-                if (!jsonOutput)
-                    spinner.setText('Gathering index information...');
-                spinner.start();
-                const indexResult = await client.query(`
-          SELECT
-            i.relname as index_name,
-            t.relname as table_name,
-            am.amname as index_type,
-            pg_relation_size(i.oid) as index_size,
-            idx.indisvalid as is_valid,
-            idx.indisunique as is_unique
-          FROM pg_index idx
-          JOIN pg_class i ON i.oid = idx.indexrelid
-          JOIN pg_class t ON t.oid = idx.indrelid
-          JOIN pg_namespace n ON n.oid = t.relnamespace
-          JOIN pg_am am ON am.oid = i.relam
-          WHERE n.nspname = $1
-          ORDER BY t.relname, i.relname
-        `, [config.schema]);
-                statusData.indexes = indexResult.rows.map(row => ({
-                    name: row.index_name,
-                    table: row.table_name,
-                    type: row.index_type,
-                    size: formatBytes(parseInt(row.index_size, 10)),
-                    valid: row.is_valid,
-                    unique: row.is_unique,
-                }));
-                if (!jsonOutput)
-                    spinner.succeed(`Found ${indexResult.rows.length} indexes`);
-            }
-            // Get migration status
-            if (!jsonOutput)
-                spinner.setText('Checking migration status...');
-            spinner.start();
-            try {
-                const migrationsResult = await client.query(`
-          SELECT version, name, applied_at
-          FROM ${config.schema}.migrations
-          ORDER BY version ASC
-        `);
-                statusData.migrations = migrationsResult.rows.map(row => ({
-                    version: row.version,
-                    name: row.name,
-                    appliedAt: row.applied_at,
-                }));
-                if (!jsonOutput)
-                    spinner.succeed(`${migrationsResult.rows.length} migrations applied`);
-            }
-            catch {
-                statusData.migrations = [];
-                if (!jsonOutput)
-                    spinner.succeed(output.warning('Could not read migrations table'));
-            }
-            await client.end();
-            // Output results
-            if (jsonOutput) {
-                output.printJson(statusData);
-            }
-            else {
-                output.writeln();
-                // Connection info
-                output.writeln(output.highlight('Connection:'));
-                output.printTable({
-                    columns: [
-                        { key: 'property', header: 'Property', width: 20 },
-                        { key: 'value', header: 'Value', width: 40 },
-                    ],
-                    data: [
-                        { property: 'Host', value: config.host },
-                        { property: 'Port', value: String(config.port) },
-                        { property: 'Database', value: config.database },
-                        { property: 'User', value: config.user },
-                        { property: 'SSL', value: config.ssl ? 'Enabled' : 'Disabled' },
-                        { property: 'Latency', value: `${connectionTime}ms` },
-                    ],
-                });
-                output.writeln();
-                // Vector extension info
-                const pgvectorData = statusData.pgvector;
-                const extDisplayName = pgvectorData.extensionName === 'monovector' ? 'MonoVector' : 'pgvector';
-                output.writeln(output.highlight(`Vector Extension (${extDisplayName}):`));
-                output.writeln(`  Status: ${pgvectorData.installed ? output.success('Installed') : output.error('Not Installed')}`);
-                if (pgvectorData.extensionName) {
-                    output.writeln(`  Extension: ${pgvectorData.extensionName}`);
-                }
-                if (pgvectorData.version) {
-                    output.writeln(`  Version: ${pgvectorData.version}`);
-                }
-                output.writeln();
-                // MonoVector info
-                output.writeln(output.highlight('MonoVector:'));
-                const monovectorData = statusData.monovector;
-                output.writeln(`  Initialized: ${monovectorData.initialized ? output.success('Yes') : output.error('No')}`);
-                if (monovectorData.version) {
-                    output.writeln(`  Version: ${monovectorData.version}`);
-                }
-                if (monovectorData.dimensions) {
-                    output.writeln(`  Dimensions: ${monovectorData.dimensions}`);
-                }
-                output.writeln();
-                // Table statistics
-                output.writeln(output.highlight('Table Statistics:'));
-                output.printTable({
-                    columns: [
-                        { key: 'name', header: 'Table', width: 30 },
-                        { key: 'rows', header: 'Rows', width: 12 },
-                        { key: 'size', header: 'Size', width: 12 },
-                        { key: 'totalSize', header: 'Total Size', width: 12 },
-                    ],
-                    data: tableStats,
-                });
-                output.writeln();
-                // Index information (verbose only)
-                if (verbose && statusData.indexes.length > 0) {
-                    output.writeln(output.highlight('Index Health:'));
-                    output.printTable({
-                        columns: [
-                            { key: 'name', header: 'Index', width: 35 },
-                            { key: 'table', header: 'Table', width: 20 },
-                            { key: 'type', header: 'Type', width: 10 },
-                            { key: 'size', header: 'Size', width: 10 },
-                            { key: 'status', header: 'Status', width: 10 },
-                        ],
-                        data: statusData.indexes.map(idx => ({
-                            ...idx,
-                            status: idx.valid ? output.success('Valid') : output.error('Invalid'),
-                        })),
-                    });
-                    output.writeln();
-                }
-                // Migration status
-                output.writeln(output.highlight('Migrations:'));
-                const migrations = statusData.migrations;
-                if (migrations.length === 0) {
-                    output.writeln('  No migrations applied');
-                }
-                else {
-                    output.printTable({
-                        columns: [
-                            { key: 'version', header: 'Version', width: 12 },
-                            { key: 'name', header: 'Name', width: 35 },
-                            { key: 'appliedAt', header: 'Applied At', width: 22 },
-                        ],
-                        data: migrations.map(m => ({
-                            ...m,
-                            appliedAt: new Date(m.appliedAt).toISOString().replace('T', ' ').substring(0, 19),
-                        })),
-                    });
-                }
-                output.writeln();
-                // Summary
-                const embeddingsTable = tableStats.find(t => t.name === 'embeddings');
-                if (embeddingsTable) {
-                    output.printBox([
-                        `Total Vectors: ${embeddingsTable.rows.toLocaleString()}`,
-                        `Storage Used: ${embeddingsTable.totalSize}`,
-                        `Schema: ${config.schema}`,
-                        `Migrations: ${migrations.length} applied`,
-                    ].join('\n'), 'Summary');
-                }
-            }
-            return { success: true, data: statusData };
-        }
-        catch (error) {
-            if (!jsonOutput)
-                spinner.fail('Status check failed');
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (jsonOutput) {
-                output.printJson({ error: errorMessage });
-            }
-            else {
-                output.printError(errorMessage);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-export default statusCommand;
-//# sourceMappingURL=status.js.map

package/packages/@monomind/cli/dist/src/commands/progress.d.ts

@@ -1,11 +0,0 @@
-/**
- * v1 Progress CLI Command
- *
- * Check and manage v1 implementation progress.
- *
- * @module @monoes/cli/commands/progress
- */
-import type { Command } from '../types.js';
-export declare const progressCommand: Command;
-export default progressCommand;
-//# sourceMappingURL=progress.d.ts.map