@lanonasis/cli 3.9.7 → 3.9.9

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog - @lanonasis/cli
 
+## [3.9.8] - 2026-02-25
+
+### ✨ New Features
+
+- **Issue #98 (CLI Memory UX Enhancements)**:
+  - Added `onasis memory create --json <json>` for direct JSON payload creation.
+  - Added `onasis memory create --content-file <path>` for file-based content ingestion.
+  - Added `onasis memory save-session` to persist branch/status/changed-files session context as memory.
+- **Behavior methods via CLI commands**:
+  - Added `onasis memory intelligence` subcommands for health check, tag suggestions, related lookup, duplicate detection, insight extraction, and pattern analysis.
+  - Added `onasis memory behavior` subcommands for `record`, `recall`, and `suggest` workflow behavior operations.
+
+### 🐛 Bug Fixes
+
+- Normalized memory response handling for create/get/update wrappers (`{ data: ... }`) so CLI output fields like ID/Title/Type are consistently resolved.
+- Ensured token refresh is executed before memory command paths to reduce intermittent re-auth prompts during active OAuth sessions.
+- Aligned default semantic search thresholds to `0.55` across memory and MCP search command paths for consistent result behavior.
+
 ## [3.9.7] - 2026-02-21
 
 ### ✨ New Features

package/dist/commands/api-keys.js

@@ -162,7 +162,7 @@ apiKeysCommand
                     validate: (input) => input.length > 0 || 'Value is required'
                 },
                 {
-                    type: 'list',
+                    type: 'select',
                     name: 'keyType',
                     message: 'Key type:',
                     when: !keyData.keyType,
@@ -177,21 +177,21 @@ apiKeysCommand
                     ]
                 },
                 {
-                    type: 'list',
+                    type: 'select',
                     name: 'environment',
                     message: 'Environment:',
                     choices: ['development', 'staging', 'production'],
                     default: 'development'
                 },
                 {
-                    type: 'list',
+                    type: 'select',
                     name: 'projectId',
                     message: 'Select project:',
                     when: !keyData.projectId && projects.length > 0,
                     choices: projects.map((p) => ({ name: `${p.name} (${p.id})`, value: p.id }))
                 },
                 {
-                    type: 'list',
+                    type: 'select',
                     name: 'accessLevel',
                     message: 'Access level:',
                     choices: ['public', 'authenticated', 'team', 'admin', 'enterprise'],
@@ -543,7 +543,7 @@ mcpCommand
                     default: false
                 },
                 {
-                    type: 'list',
+                    type: 'select',
                     name: 'riskLevel',
                     message: 'Risk level:',
                     choices: ['low', 'medium', 'high', 'critical'],
@@ -647,7 +647,7 @@ mcpCommand
             const tools = await apiClient.get('/api-keys/mcp/tools');
             const answers = await inquirer.prompt([
                 {
-                    type: 'list',
+                    type: 'select',
                     name: 'toolId',
                     message: 'Select MCP tool:',
                     when: !requestData.toolId && tools.length > 0,
@@ -672,7 +672,7 @@ mcpCommand
                     validate: (input) => input.length > 0 || 'At least one key name is required'
                 },
                 {
-                    type: 'list',
+                    type: 'select',
                     name: 'environment',
                     message: 'Environment:',
                     when: !requestData.environment,

package/dist/commands/auth.js

@@ -569,7 +569,7 @@ export async function loginCommand(options) {
     // Show authentication options
     const authChoice = await inquirer.prompt([
         {
-            type: 'list',
+            type: 'select',
             name: 'method',
             message: 'Choose authentication method:',
             choices: [
@@ -821,7 +821,7 @@ async function handleCredentialsFlow(options, config) {
         }
         // Store JWT token for API authentication
         await config.setToken(authToken);
-        await config.set('authMethod', 'jwt');
+        await config.setAndSave('authMethod', 'jwt');
         spinner.succeed('Login successful');
         console.log();
         console.log(chalk.green('✓ Authenticated successfully'));

package/dist/commands/completion.js

@@ -132,6 +132,16 @@ export async function generateCompletionData() {
                         description: 'Show memory statistics',
                         options: []
                     },
+                    {
+                        name: 'intelligence',
+                        description: 'Memory intelligence operations (use: memory intelligence --help)',
+                        options: []
+                    },
+                    {
+                        name: 'behavior',
+                        description: 'Behavior pattern operations (use: memory behavior --help)',
+                        options: []
+                    },
                     {
                         name: 'bulk-delete',
                         description: 'Delete multiple memories',

package/dist/commands/guide.js

@@ -188,7 +188,7 @@ export class UserGuidanceSystem {
                 default: 'https://api.lanonasis.com/api/v1'
             },
             {
-                type: 'list',
+                type: 'select',
                 name: 'outputFormat',
                 message: 'Preferred output format:',
                 choices: ['table', 'json', 'yaml', 'csv'],
@@ -206,7 +206,7 @@ export class UserGuidanceSystem {
         console.log();
         const { authMethod } = await inquirer.prompt([
             {
-                type: 'list',
+                type: 'select',
                 name: 'authMethod',
                 message: 'Choose authentication method:',
                 choices: [
@@ -335,7 +335,7 @@ export class UserGuidanceSystem {
         console.log();
         const { shell } = await inquirer.prompt([
             {
-                type: 'list',
+                type: 'select',
                 name: 'shell',
                 message: 'Which shell do you use?',
                 choices: [

package/dist/commands/mcp.js

@@ -4,9 +4,42 @@ import { table } from 'table';
 import { getMCPClient } from '../utils/mcp-client.js';
 import { EnhancedMCPClient } from '../mcp/client/enhanced-client.js';
 import { CLIConfig } from '../utils/config.js';
+import { apiClient } from '../utils/api.js';
 import WebSocket from 'ws';
 import { dirname, join } from 'path';
 import { createConnectionManager } from '../ux/index.js';
+const tokenizeQuery = (input) => input
+    .toLowerCase()
+    .split(/[^a-z0-9]+/g)
+    .map((token) => token.trim())
+    .filter((token) => token.length >= 2);
+const lexicalScore = (query, memory) => {
+    const tokens = tokenizeQuery(query);
+    if (tokens.length === 0)
+        return 0;
+    const haystack = `${memory.title || ''} ${memory.content || ''} ${(memory.tags || []).join(' ')}`.toLowerCase();
+    const hits = tokens.filter((token) => haystack.includes(token)).length;
+    if (hits === 0)
+        return 0;
+    const ratio = hits / tokens.length;
+    return Math.max(0.35, Math.min(0.69, Number((ratio * 0.65).toFixed(3))));
+};
+const fallbackMemorySearch = async (query, limit) => {
+    const candidateLimit = Math.min(Math.max(limit * 8, 50), 200);
+    const memoriesResult = await apiClient.getMemories({ page: 1, limit: candidateLimit });
+    const candidates = (memoriesResult.memories || memoriesResult.data || []);
+    return candidates
+        .map((memory) => ({
+        id: memory.id,
+        title: memory.title,
+        memory_type: memory.memory_type,
+        similarity_score: lexicalScore(query, memory),
+        content: memory.content || ''
+    }))
+        .filter((memory) => memory.similarity_score > 0)
+        .sort((a, b) => b.similarity_score - a.similarity_score)
+        .slice(0, limit);
+};
 /**
  * Register MCP-related CLI commands (mcp and mcp-server) on a Commander program.
  *
@@ -460,25 +493,54 @@ export function mcpCommands(program) {
     });
     memory.command('search')
         .description('Search memories via MCP')
-        .argument('<query>', 'Search query')
+        .argument('<query...>', 'Search query')
         .option('-l, --limit <number>', 'Maximum results', '10')
-        .option('-t, --threshold <number>', 'Similarity threshold (0-1)', '0.7')
-        .action(async (query, options) => {
+        .option('-t, --threshold <number>', 'Similarity threshold (0-1)', '0.55')
+        .action(async (queryParts, options) => {
+        const query = Array.isArray(queryParts) ? queryParts.join(' ').trim() : String(queryParts || '').trim();
+        if (!query) {
+            console.error(chalk.red('Search query is required'));
+            process.exit(1);
+        }
         const spinner = ora('Searching memories via MCP...').start();
+        const client = getMCPClient();
         try {
-            const client = getMCPClient();
             if (!client.isConnectedToServer()) {
                 spinner.info('Not connected. Attempting auto-connect...');
                 const config = new CLIConfig();
                 const useRemote = !!config.get('token');
                 await client.connect({ useRemote });
             }
-            const results = await client.callTool('memory_search_memories', {
-                query,
-                limit: parseInt(options.limit),
-                threshold: parseFloat(options.threshold)
-            });
-            spinner.succeed(`Found ${results.length} memories`);
+            const limit = parseInt(options.limit);
+            const threshold = parseFloat(options.threshold);
+            let results = [];
+            let usedLexicalFallback = false;
+            try {
+                const rawResult = await client.callTool('memory_search_memories', {
+                    query,
+                    limit,
+                    threshold
+                });
+                results = Array.isArray(rawResult)
+                    ? rawResult
+                    : Array.isArray(rawResult?.results)
+                        ? rawResult.results
+                        : Array.isArray(rawResult?.result)
+                            ? rawResult.result
+                            : [];
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                if (/vector dimensions|hybrid search failed|memory search failed/i.test(message)) {
+                    spinner.info('Semantic search unavailable in MCP path, using lexical fallback...');
+                    results = await fallbackMemorySearch(query, limit);
+                    usedLexicalFallback = true;
+                }
+                else {
+                    throw error;
+                }
+            }
+            spinner.succeed(`Found ${results.length} memories${usedLexicalFallback ? ' (lexical fallback)' : ''}`);
             if (results.length === 0) {
                 console.log(chalk.yellow('\nNo memories found matching your query'));
                 return;
@@ -488,7 +550,7 @@ export function mcpCommands(program) {
                 console.log(`\n${chalk.bold(`${index + 1}. ${memory.title}`)}`);
                 console.log(`   ID: ${chalk.gray(memory.id)}`);
                 console.log(`   Type: ${chalk.blue(memory.memory_type)}`);
-                console.log(`   Score: ${chalk.green((memory.relevance_score * 100).toFixed(1) + '%')}`);
+                console.log(`   Score: ${chalk.green((memory.similarity_score * 100).toFixed(1) + '%')}`);
                 console.log(`   Content: ${memory.content.substring(0, 100)}...`);
             });
         }
@@ -496,6 +558,11 @@ export function mcpCommands(program) {
             spinner.fail(`Search failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
             process.exit(1);
         }
+        finally {
+            if (client.isConnectedToServer()) {
+                await client.disconnect().catch(() => { });
+            }
+        }
     });
     // Configure MCP preferences
     mcp.command('config')