@claude-flow/cli 3.28.0 → 3.30.0

package/dist/src/commands/hooks.js

@@ -3942,15 +3942,15 @@ const tokenOptimizeCommand = {
                 const total = stats.cacheHits + stats.cacheMisses;
                 const hitRate = total > 0 ? (stats.cacheHits / total * 100).toFixed(1) : '0';
                 const savings = (stats.totalTokensSaved / 1000 * 0.01).toFixed(2);
-                output.writeln(`## Token Optimization Report
-
-| Metric | Value |
-|--------|-------|
-| Tokens Saved | ${stats.totalTokensSaved.toLocaleString()} |
-| Edits Optimized | ${stats.editsOptimized} |
-| Cache Hit Rate | ${hitRate}% |
-| Memories Retrieved | ${stats.memoriesRetrieved} |
-| Est. Monthly Savings | $${savings} |
+                output.writeln(`## Token Optimization Report
+
+| Metric | Value |
+|--------|-------|
+| Tokens Saved | ${stats.totalTokensSaved.toLocaleString()} |
+| Edits Optimized | ${stats.editsOptimized} |
+| Cache Hit Rate | ${hitRate}% |
+| Memories Retrieved | ${stats.memoriesRetrieved} |
+| Est. Monthly Savings | $${savings} |
 | Agentic-Flow Active | ${agenticFlowAvailable ? '✓' : '✗'} |`);
             }
             return { success: true, data: { config, stats: { ...stats, agenticFlowAvailable } } };

package/dist/src/commands/index.js

@@ -83,6 +83,10 @@ const commandLoaders = {
     proxy: () => import('./proxy.js'),
     // Fable co-pilot advisor tip in the statusline insight ticker (ADR-316)
     advisor: () => import('./advisor.js'),
+    // Ruflo verbs in Claude Code's spinnerVerbs rotation (ADR-318)
+    spinner: () => import('./spinner.js'),
+    // Ruflo entries in Claude Code's companyAnnouncements startup rotation (ADR-319)
+    announcements: () => import('./announcements.js'),
 };
 // Cache for loaded commands
 const loadedCommands = new Map();

package/dist/src/commands/init.js

@@ -8,6 +8,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { executeInit, executeUpgrade, executeUpgradeWithMissing, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, } from '../init/index.js';
 import { ENROLLMENT_SCREEN, recordEnrollmentOutcome, shouldOfferEnrollment, } from '../funnel/enrollment.js';
+import { commandExists } from '../services/harness-hosts.js';
 /**
  * ADR-302 post-init capability enrollment. One-time, interactive-TTY-only,
  * skippable with --no-signup, auto-skipped in CI/automation. Never throws
@@ -42,6 +43,87 @@ async function offerCapabilityEnrollment(ctx) {
         // Enrollment is optional; init success is never affected.
     }
 }
+async function resolveCodexInitializer(cwd) {
+    // Use a variable to prevent TypeScript from statically resolving the optional module
+    const codexModuleId = '@claude-flow/codex';
+    const resolutionStrategies = [
+        // Strategy 1: Direct import (works if installed as CLI dependency)
+        async () => (await import(codexModuleId)).CodexInitializer,
+        // Strategy 2: Project node_modules (works if installed in user's project)
+        async () => {
+            const projectPath = path.join(cwd, 'node_modules', '@claude-flow', 'codex', 'dist', 'index.js');
+            if (fs.existsSync(projectPath)) {
+                const mod = await import(`file://${projectPath}`);
+                return mod.CodexInitializer;
+            }
+            throw new Error('Not found in project');
+        },
+        // Strategy 3: Global node_modules
+        async () => {
+            const { execSync } = await import('child_process');
+            const globalPath = execSync('npm root -g', { encoding: 'utf-8' }).trim();
+            const codexPath = path.join(globalPath, '@claude-flow', 'codex', 'dist', 'index.js');
+            if (fs.existsSync(codexPath)) {
+                const mod = await import(`file://${codexPath}`);
+                return mod.CodexInitializer;
+            }
+            throw new Error('Not found globally');
+        },
+    ];
+    for (const strategy of resolutionStrategies) {
+        try {
+            const ctor = await strategy();
+            if (ctor)
+                return ctor;
+        }
+        catch {
+            // Try next strategy
+        }
+    }
+    return undefined;
+}
+// #2666-adjacent — quietly wire up Codex too when a plain `ruflo init` (no
+// --codex/--dual) runs on a machine that also has the OpenAI Codex CLI on
+// PATH: registers its MCP server and installs skills alongside the Claude
+// Code setup that just happened. Best-effort and silent-by-default — must
+// never fail or noisily interrupt a normal init. Opt out with
+// --no-codex-detect. Skipped entirely under --skip-claude (runtime-only
+// init) and scripted `--format json` output.
+async function maybeAutoDetectCodex(ctx, options) {
+    try {
+        if (ctx.flags['no-codex-detect'] === true)
+            return;
+        if (ctx.flags.format === 'json')
+            return; // scripted output stays pure
+        if (!commandExists('codex'))
+            return;
+        const CodexInitializer = await resolveCodexInitializer(ctx.cwd);
+        if (!CodexInitializer) {
+            output.writeln();
+            output.printInfo('Detected the OpenAI Codex CLI — install @claude-flow/codex to auto-configure its MCP server and skills:');
+            output.writeln(output.dim('  npm install @claude-flow/codex && ruflo init --codex'));
+            return;
+        }
+        const initializer = new CodexInitializer();
+        const result = await initializer.initialize({
+            projectPath: ctx.cwd,
+            template: (options.minimal ? 'minimal' : options.full ? 'full' : 'default'),
+            force: options.force,
+            dual: false, // Claude Code files were already written by the main init flow above
+        });
+        if (!result.success)
+            return; // best-effort — never fail the primary init over this
+        output.writeln();
+        output.printBox([
+            `AGENTS.md:            Codex project instructions`,
+            `.agents/config.toml:  MCP server + skills config`,
+            `.agents/skills/:      ${result.skillsGenerated.length} skills`,
+        ].join('\n'), 'OpenAI Codex detected — configured');
+    }
+    catch {
+        // Codex auto-detect is a bonus, never a requirement — swallow everything.
+    }
+}
 // Codex initialization action
 async function initCodexAction(ctx, options) {
     const { force, minimal, full, dualMode } = options;
@@ -53,44 +135,7 @@ async function initCodexAction(ctx, options) {
     const spinner = output.createSpinner({ text: 'Initializing Codex project...' });
     spinner.start();
     try {
-        let CodexInitializer;
-        // Try multiple resolution strategies for the @claude-flow/codex package
-        // Use a variable to prevent TypeScript from statically resolving the optional module
-        const codexModuleId = '@claude-flow/codex';
-        const resolutionStrategies = [
-            // Strategy 1: Direct import (works if installed as CLI dependency)
-            async () => (await import(codexModuleId)).CodexInitializer,
-            // Strategy 2: Project node_modules (works if installed in user's project)
-            async () => {
-                const projectPath = path.join(ctx.cwd, 'node_modules', '@claude-flow', 'codex', 'dist', 'index.js');
-                if (fs.existsSync(projectPath)) {
-                    const mod = await import(`file://${projectPath}`);
-                    return mod.CodexInitializer;
-                }
-                throw new Error('Not found in project');
-            },
-            // Strategy 3: Global node_modules
-            async () => {
-                const { execSync } = await import('child_process');
-                const globalPath = execSync('npm root -g', { encoding: 'utf-8' }).trim();
-                const codexPath = path.join(globalPath, '@claude-flow', 'codex', 'dist', 'index.js');
-                if (fs.existsSync(codexPath)) {
-                    const mod = await import(`file://${codexPath}`);
-                    return mod.CodexInitializer;
-                }
-                throw new Error('Not found globally');
-            },
-        ];
-        for (const strategy of resolutionStrategies) {
-            try {
-                CodexInitializer = await strategy();
-                if (CodexInitializer)
-                    break;
-            }
-            catch {
-                // Try next strategy
-            }
-        }
+        const CodexInitializer = await resolveCodexInitializer(ctx.cwd);
         if (!CodexInitializer) {
             throw new Error('Cannot find module @claude-flow/codex');
         }
@@ -357,6 +402,10 @@ const initAction = async (ctx) => {
             output.printInfo(`Hooks: ${result.summary.hooksEnabled} hook types enabled in settings.json`);
             output.writeln();
         }
+        // #2666-adjacent — auto-detect + configure OpenAI Codex CLI if present
+        if (!skipClaude) {
+            await maybeAutoDetectCodex(ctx, { force, minimal, full });
+        }
         // Handle --start-all or --start-daemon
         const startAll = ctx.flags['start-all'] || ctx.flags.startAll;
         const startDaemon = ctx.flags['start-daemon'] || ctx.flags.startDaemon || startAll;
@@ -1112,6 +1161,12 @@ export const initCommand = {
             type: 'boolean',
             default: false,
         },
+        {
+            name: 'no-codex-detect',
+            description: 'Skip auto-detecting the OpenAI Codex CLI and configuring its MCP server + skills',
+            type: 'boolean',
+            default: false,
+        },
         {
             name: 'all-agents',
             description: 'Install all agent categories (ADR-128: default is ~24 substrate agents; this restores the full set of ~89)',
@@ -1139,6 +1194,7 @@ export const initCommand = {
         { command: 'claude-flow init --codex', description: 'Initialize for OpenAI Codex (AGENTS.md)' },
         { command: 'claude-flow init --codex --full', description: 'Codex init with all 137+ skills' },
         { command: 'claude-flow init --dual', description: 'Initialize for both Claude Code and Codex' },
+        { command: 'claude-flow init --no-codex-detect', description: 'Skip auto-configuring OpenAI Codex even if it is installed' },
         { command: 'claude-flow init --all-agents', description: 'Install all agent categories (~89 agents; ADR-128 opt-in)' },
     ],
     action: initAction,

package/dist/src/commands/memory.js

@@ -646,6 +646,90 @@ const deleteCommand = {
         }
     }
 };
+// #2666 — Hard, namespace-scoped purge. `delete` above only ever
+// soft-deletes a single key (status='deleted', row stays and still occupies
+// the UNIQUE(namespace, key) slot — #2652). Reconciling an entire namespace
+// after its source-of-truth changed (e.g. a plugin's index after a source
+// file was removed) needs the row to actually be gone, not tombstoned.
+// Irreversible — always requires --namespace explicitly (no default) and
+// either interactive confirmation or --force.
+const purgeCommand = {
+    name: 'purge',
+    description: 'Permanently delete every entry in a namespace (hard delete — not the soft delete/tombstone that `memory delete` uses)',
+    options: [
+        {
+            name: 'namespace',
+            short: 'n',
+            description: 'Namespace to purge (required — no default, to avoid an accidental whole-namespace wipe)',
+            type: 'string'
+        },
+        {
+            name: 'dry-run',
+            short: 'd',
+            description: 'Report how many entries would be deleted, without deleting them',
+            type: 'boolean',
+            default: false
+        },
+        {
+            name: 'force',
+            short: 'f',
+            description: 'Skip confirmation',
+            type: 'boolean',
+            default: false
+        },
+        DB_PATH_OPTION
+    ],
+    examples: [
+        { command: 'claude-flow memory purge --namespace stale-cache --dry-run', description: 'Preview a purge' },
+        { command: 'claude-flow memory purge --namespace stale-cache --force', description: 'Purge without confirmation (e.g. in a script)' }
+    ],
+    action: async (ctx) => {
+        const namespace = ctx.flags.namespace;
+        const dryRun = ctx.flags.dryRun;
+        const force = ctx.flags.force;
+        const dbPath = ctx.flags.path;
+        if (!namespace) {
+            output.printError('Namespace is required. Use: memory purge -n "namespace" [--dry-run | --force]');
+            return { success: false, exitCode: 1 };
+        }
+        try {
+            const { listEntries, purgeNamespace, resolveDbPath: _rdbPurge } = await import('../memory/memory-initializer.js');
+            const resolvedDbPath = _rdbPurge(dbPath);
+            const preview = await listEntries({ namespace, limit: 1, dbPath: resolvedDbPath });
+            const previewCount = preview.total ?? preview.entries?.length ?? 0;
+            if (dryRun) {
+                output.printInfo(`Would permanently delete ${previewCount} entr${previewCount === 1 ? 'y' : 'ies'} from namespace "${namespace}" (dry run — nothing deleted)`);
+                return { success: true, data: { namespace, wouldDelete: previewCount } };
+            }
+            if (!force && ctx.interactive) {
+                const confirmed = await confirm({
+                    message: `Permanently delete ${previewCount} entr${previewCount === 1 ? 'y' : 'ies'} from namespace "${namespace}"? This is a hard delete — not reversible with \`memory delete\`'s soft-undo.`,
+                    default: false
+                });
+                if (!confirmed) {
+                    output.printInfo('Operation cancelled');
+                    return { success: true };
+                }
+            }
+            else if (!force) {
+                output.printError(`Refusing to purge namespace "${namespace}" without --force in non-interactive mode`);
+                return { success: false, exitCode: 1 };
+            }
+            const result = await purgeNamespace({ namespace, dbPath: resolvedDbPath });
+            if (!result.success) {
+                output.printError(result.error || 'Failed to purge');
+                return { success: false, exitCode: 1 };
+            }
+            output.printSuccess(`Purged ${result.deletedCount} entr${result.deletedCount === 1 ? 'y' : 'ies'} from namespace "${namespace}"`);
+            output.printInfo(`Remaining entries (all namespaces): ${result.remainingEntries}`);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            output.printError(`Failed to purge: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return { success: false, exitCode: 1 };
+        }
+    }
+};
 // Stats command
 const statsCommand = {
     name: 'stats',
@@ -1476,7 +1560,7 @@ const initMemoryCommand = {
 export const memoryCommand = {
     name: 'memory',
     description: 'Memory management commands',
-    subcommands: [initMemoryCommand, storeCommand, retrieveCommand, searchCommand, listCommand, deleteCommand, statsCommand, configureCommand, cleanupCommand, compressCommand, exportCommand, importCommand, distillCommand, backupCommand],
+    subcommands: [initMemoryCommand, storeCommand, retrieveCommand, searchCommand, listCommand, deleteCommand, purgeCommand, statsCommand, configureCommand, cleanupCommand, compressCommand, exportCommand, importCommand, distillCommand, backupCommand],
     options: [],
     examples: [
         { command: 'claude-flow memory store -k "key" -v "value"', description: 'Store data' },

package/dist/src/commands/ruvector/backup.js

@@ -182,10 +182,10 @@ const backupSubcommand = {
                 tables = tablesFilter.split(',').map(t => t.trim());
             }
             else {
-                const tablesResult = await client.query(`
-          SELECT table_name FROM information_schema.tables
-          WHERE table_schema = $1 AND table_type = 'BASE TABLE'
-          ORDER BY table_name
+                const tablesResult = await client.query(`
+          SELECT table_name FROM information_schema.tables
+          WHERE table_schema = $1 AND table_type = 'BASE TABLE'
+          ORDER BY table_name
         `, [config.schema]);
                 tables = tablesResult.rows.map(r => r.table_name);
             }
@@ -209,16 +209,16 @@ const backupSubcommand = {
                 spinner.setText(`Exporting ${tableName}...`);
                 spinner.start();
                 // Get columns
-                const columnsResult = await client.query(`
-          SELECT column_name, data_type
-          FROM information_schema.columns
-          WHERE table_schema = $1 AND table_name = $2
-          ORDER BY ordinal_position
+                const columnsResult = await client.query(`
+          SELECT column_name, data_type
+          FROM information_schema.columns
+          WHERE table_schema = $1 AND table_name = $2
+          ORDER BY ordinal_position
         `, [config.schema, tableName]);
                 const columns = columnsResult.rows.map(r => r.column_name);
                 // Get data
-                const dataResult = await client.query(`
-          SELECT * FROM ${config.schema}.${tableName}
+                const dataResult = await client.query(`
+          SELECT * FROM ${config.schema}.${tableName}
         `);
                 backupData.tables.push({
                     name: tableName,
@@ -233,14 +233,14 @@ const backupSubcommand = {
             if (includeIndexes) {
                 spinner.setText('Exporting index definitions...');
                 spinner.start();
-                const indexResult = await client.query(`
-          SELECT pg_get_indexdef(i.oid) as indexdef
-          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
-          WHERE n.nspname = $1
-            AND NOT idx.indisprimary
+                const indexResult = await client.query(`
+          SELECT pg_get_indexdef(i.oid) as indexdef
+          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
+          WHERE n.nspname = $1
+            AND NOT idx.indisprimary
         `, [config.schema]);
                 backupData.indexes = indexResult.rows.map(r => r.indexdef);
                 spinner.succeed(`Exported ${backupData.indexes.length} index definitions`);
@@ -566,10 +566,10 @@ const restoreSubcommand = {
                             return typeof val === 'object' ? JSON.stringify(val) : val;
                         });
                         try {
-                            await client.query(`
-                INSERT INTO ${config.schema}.${table.name} (${columns.join(', ')})
-                VALUES (${values.join(', ')})
-                ON CONFLICT DO NOTHING
+                            await client.query(`
+                INSERT INTO ${config.schema}.${table.name} (${columns.join(', ')})
+                VALUES (${values.join(', ')})
+                ON CONFLICT DO NOTHING
               `, params);
                             restoredRows++;
                         }

package/dist/src/commands/ruvector/benchmark.js

@@ -228,8 +228,8 @@ export const benchmarkCommand = {
             spinner.succeed('Connected to PostgreSQL');
             // Detect vector extension type: prefer ruvector, fall back to pgvector
             let vectorTypeName = 'vector';
-            const ruvectorCheck = await client.query(`
-        SELECT extname FROM pg_extension WHERE extname = 'ruvector'
+            const ruvectorCheck = await client.query(`
+        SELECT extname FROM pg_extension WHERE extname = 'ruvector'
       `);
             if (ruvectorCheck.rows.length > 0) {
                 vectorTypeName = 'ruvector';
@@ -238,12 +238,12 @@ export const benchmarkCommand = {
             const benchmarkTable = `${config.schema}.benchmark_${Date.now()}`;
             spinner.setText('Creating benchmark table...');
             spinner.start();
-            await client.query(`
-        CREATE TABLE ${benchmarkTable} (
-          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-          embedding ${vectorTypeName}(${dimensions}),
-          created_at TIMESTAMPTZ DEFAULT NOW()
-        )
+            await client.query(`
+        CREATE TABLE ${benchmarkTable} (
+          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+          embedding ${vectorTypeName}(${dimensions}),
+          created_at TIMESTAMPTZ DEFAULT NOW()
+        )
       `);
             spinner.succeed('Benchmark table created');
             // Insert vectors
@@ -259,9 +259,9 @@ export const benchmarkCommand = {
                     const vector = generateRandomVector(dimensions);
                     batchVectors.push(`('[${vector.join(',')}]')`);
                 }
-                await client.query(`
-          INSERT INTO ${benchmarkTable} (embedding)
-          VALUES ${batchVectors.join(',')}
+                await client.query(`
+          INSERT INTO ${benchmarkTable} (embedding)
+          VALUES ${batchVectors.join(',')}
         `);
                 insertedCount = batchEnd;
                 spinner.setText(`Inserting vectors... ${insertedCount.toLocaleString()}/${numVectors.toLocaleString()}`);
@@ -283,21 +283,21 @@ export const benchmarkCommand = {
                 const metricOp = metric === 'cosine' ? `${opsPrefix}_cosine_ops` :
                     metric === 'l2' ? `${opsPrefix}_l2_ops` : `${opsPrefix}_ip_ops`;
                 if (indexType === 'hnsw') {
-                    await client.query(`
-            CREATE INDEX idx_benchmark_hnsw
-            ON ${benchmarkTable}
-            USING hnsw (embedding ${metricOp})
-            WITH (m = 16, ef_construction = 64)
+                    await client.query(`
+            CREATE INDEX idx_benchmark_hnsw
+            ON ${benchmarkTable}
+            USING hnsw (embedding ${metricOp})
+            WITH (m = 16, ef_construction = 64)
           `);
                 }
                 else if (indexType === 'ivfflat') {
                     // Need to train IVFFlat with existing data
                     const lists = Math.max(100, Math.floor(numVectors / 1000));
-                    await client.query(`
-            CREATE INDEX idx_benchmark_ivfflat
-            ON ${benchmarkTable}
-            USING ivfflat (embedding ${metricOp})
-            WITH (lists = ${lists})
+                    await client.query(`
+            CREATE INDEX idx_benchmark_ivfflat
+            ON ${benchmarkTable}
+            USING ivfflat (embedding ${metricOp})
+            WITH (lists = ${lists})
           `);
                 }
                 const indexDuration = Date.now() - indexStart;
@@ -320,11 +320,11 @@ export const benchmarkCommand = {
             for (let q = 0; q < numQueries; q++) {
                 const queryVector = generateRandomVector(dimensions);
                 const queryStart = Date.now();
-                await client.query(`
-          SELECT id, embedding ${distanceOp} '[${queryVector.join(',')}]' as distance
-          FROM ${benchmarkTable}
-          ORDER BY embedding ${distanceOp} '[${queryVector.join(',')}]'
-          LIMIT ${topK}
+                await client.query(`
+          SELECT id, embedding ${distanceOp} '[${queryVector.join(',')}]' as distance
+          FROM ${benchmarkTable}
+          ORDER BY embedding ${distanceOp} '[${queryVector.join(',')}]'
+          LIMIT ${topK}
         `);
                 queryLatencies.push(Date.now() - queryStart);
                 if (q % 10 === 0) {
@@ -354,11 +354,11 @@ export const benchmarkCommand = {
             // Get memory usage
             spinner.setText('Analyzing memory usage...');
             spinner.start();
-            const sizeResult = await client.query(`
-        SELECT
-          pg_relation_size('${benchmarkTable}') as table_size,
-          pg_total_relation_size('${benchmarkTable}') as total_size,
-          pg_indexes_size('${benchmarkTable}') as index_size
+            const sizeResult = await client.query(`
+        SELECT
+          pg_relation_size('${benchmarkTable}') as table_size,
+          pg_total_relation_size('${benchmarkTable}') as total_size,
+          pg_indexes_size('${benchmarkTable}') as index_size
       `);
             const tableSize = parseInt(sizeResult.rows[0].table_size, 10);
             const totalSize = parseInt(sizeResult.rows[0].total_size, 10);

package/dist/src/commands/ruvector/import.js

@@ -61,20 +61,20 @@ function generateInsertSQL(entry) {
     const updatedAt = entry.updated_at
         ? `'${escapeString(validateTimestamp(String(entry.updated_at)))}'::timestamptz`
         : 'NOW()';
-    return `INSERT INTO claude_flow.memory_entries (key, value, embedding, namespace, metadata, created_at, updated_at)
-VALUES (
-  '${key}',
-  '${value}',
-  ${embeddingClause},
-  '${namespace}',
-  '${metadata}'::jsonb,
-  ${createdAt},
-  ${updatedAt}
-)
-ON CONFLICT (key, namespace) DO UPDATE SET
-  value = EXCLUDED.value,
-  embedding = COALESCE(EXCLUDED.embedding, claude_flow.memory_entries.embedding),
-  metadata = EXCLUDED.metadata,
+    return `INSERT INTO claude_flow.memory_entries (key, value, embedding, namespace, metadata, created_at, updated_at)
+VALUES (
+  '${key}',
+  '${value}',
+  ${embeddingClause},
+  '${namespace}',
+  '${metadata}'::jsonb,
+  ${createdAt},
+  ${updatedAt}
+)
+ON CONFLICT (key, namespace) DO UPDATE SET
+  value = EXCLUDED.value,
+  embedding = COALESCE(EXCLUDED.embedding, claude_flow.memory_entries.embedding),
+  metadata = EXCLUDED.metadata,
   updated_at = NOW();`;
 }
 /**