@unifiedmemory/cli 1.0.1 → 1.2.0

package/lib/provider-detector.js

@@ -1,6 +1,8 @@
 import os from 'os';
 import path from 'path';
 import fs from 'fs-extra';
+import TOML from '@iarna/toml';
+import { getMemoryInstructions, MEMORY_INSTRUCTIONS_MARKER } from './memory-instructions.js';
 
 class ProviderDetector {
   constructor(projectDir = null) {
@@ -57,13 +59,14 @@ class BaseProvider {
     }
   }
 
-  configureMCP() {
+  configureMCP(toolPermissions = null) {
     // NEW APPROACH: Configure local server instead of HTTP
     // No parameters needed - local server reads from filesystem
+    // toolPermissions parameter for Claude Code compatibility (unused in base class)
     const config = this.readConfig() || { mcpServers: {} };
 
     config.mcpServers = config.mcpServers || {};
-    config.mcpServers.vault = {
+    config.mcpServers.unifiedmemory = {
       command: "um",
       args: ["mcp", "serve"]
     };
@@ -71,9 +74,37 @@ class BaseProvider {
     return this.writeConfig(config);
   }
 
-  installHook(hookType, scriptContent) {
-    // Implemented by providers that support hooks
-    return false;
+  /**
+   * Write memory instructions to specified file
+   * @param {string} filePath - Path to instruction file
+   * @param {string} assistantName - Display name for logging
+   * @returns {object} - Status object with status and optional error
+   */
+  writeMemoryInstructions(filePath, assistantName = 'assistant') {
+    try {
+      const instructions = getMemoryInstructions();
+
+      // Check if file exists
+      if (fs.existsSync(filePath)) {
+        // Check if marker already present
+        const existing = fs.readFileSync(filePath, 'utf8');
+        if (existing.includes(MEMORY_INSTRUCTIONS_MARKER)) {
+          // Instructions already present, skip
+          return { status: 'skipped', reason: 'already_present' };
+        }
+        // Append to existing file
+        fs.appendFileSync(filePath, '\n\n' + instructions);
+        return { status: 'appended' };
+      } else {
+        // Create new file
+        fs.ensureFileSync(filePath);
+        fs.writeFileSync(filePath, instructions);
+        return { status: 'created' };
+      }
+    } catch (e) {
+      console.error(`Failed to write memory instructions: ${e.message}`);
+      return { status: 'error', error: e.message };
+    }
   }
 }
 
@@ -106,19 +137,19 @@ class ClaudeProvider extends BaseProvider {
     }
   }
 
-  configureMCP() {
+  configureMCP(toolPermissions = null) {
     // Create .mcp.json at project root with local server config
     const success = super.configureMCP();
 
     if (success) {
       // Update .claude/settings.local.json to enable the MCP server
-      this.updateClaudeSettings();
+      this.updateClaudeSettings(toolPermissions);
     }
 
     return success;
   }
 
-  updateClaudeSettings() {
+  updateClaudeSettings(toolPermissions = null) {
     if (!this.settingsPath) return false;
 
     try {
@@ -131,12 +162,29 @@ class ClaudeProvider extends BaseProvider {
       // Add or update the required settings
       settings.enableAllProjectMcpServers = true;
 
-      // Ensure vault is in the enabled servers list
+      // Ensure unifiedmemory is in the enabled servers list
       if (!settings.enabledMcpjsonServers) {
         settings.enabledMcpjsonServers = [];
       }
-      if (!settings.enabledMcpjsonServers.includes('vault')) {
-        settings.enabledMcpjsonServers.push('vault');
+      if (!settings.enabledMcpjsonServers.includes('unifiedmemory')) {
+        settings.enabledMcpjsonServers.push('unifiedmemory');
+      }
+
+      // Add tool permissions if provided
+      if (toolPermissions && Array.isArray(toolPermissions) && toolPermissions.length > 0) {
+        if (!settings.permissions) {
+          settings.permissions = { allow: [] };
+        }
+        if (!settings.permissions.allow) {
+          settings.permissions.allow = [];
+        }
+
+        // Add new permissions, avoiding duplicates
+        toolPermissions.forEach(permission => {
+          if (!settings.permissions.allow.includes(permission)) {
+            settings.permissions.allow.push(permission);
+          }
+        });
       }
 
       // Write settings
@@ -149,19 +197,10 @@ class ClaudeProvider extends BaseProvider {
     }
   }
 
-  installHook(hookType, scriptContent) {
-    if (hookType !== 'prompt-submit' || !this.hooksDir) return false;
-
-    const hookPath = path.join(this.hooksDir, 'prompt-submit');
-
-    try {
-      fs.ensureDirSync(this.hooksDir);
-      fs.writeFileSync(hookPath, scriptContent, { mode: 0o755 });
-      return true;
-    } catch (e) {
-      console.error(`Failed to install hook: ${e.message}`);
-      return false;
-    }
+  configureMemoryInstructions() {
+    if (!this.projectDir) return { status: 'skipped', reason: 'no_project_dir' };
+    const instructionPath = path.join(this.projectDir, 'CLAUDE.md');
+    return this.writeMemoryInstructions(instructionPath, 'Claude Code');
   }
 }
 
@@ -172,6 +211,12 @@ class CursorProvider extends BaseProvider {
     // Detect by directory existence, not config file
     super('Cursor', configPath, false, baseDir);
   }
+
+  configureMemoryInstructions() {
+    // Use project-level file (assuming we're in a project directory)
+    const instructionPath = path.join(process.cwd(), 'CURSOR.md');
+    return this.writeMemoryInstructions(instructionPath, 'Cursor');
+  }
 }
 
 class ClineProvider extends BaseProvider {
@@ -181,6 +226,12 @@ class ClineProvider extends BaseProvider {
     // Detect by directory existence, not config file
     super('Cline', configPath, false, baseDir);
   }
+
+  configureMemoryInstructions() {
+    // Use project-level file
+    const instructionPath = path.join(process.cwd(), 'CLINE.md');
+    return this.writeMemoryInstructions(instructionPath, 'Cline');
+  }
 }
 
 class CodexProvider extends BaseProvider {
@@ -194,7 +245,7 @@ class CodexProvider extends BaseProvider {
     if (!fs.existsSync(this.configPath)) return null;
     try {
       const content = fs.readFileSync(this.configPath, 'utf8');
-      return this.parseTOML(content);
+      return TOML.parse(content);
     } catch (e) {
       return null;
     }
@@ -203,8 +254,8 @@ class CodexProvider extends BaseProvider {
   writeConfig(config) {
     try {
       fs.ensureFileSync(this.configPath);
-      const tomlContent = this.generateTOML(config);
-      fs.writeFileSync(this.configPath, tomlContent);
+      const tomlContent = TOML.stringify(config);
+      fs.writeFileSync(this.configPath, tomlContent, 'utf8');
       return true;
     } catch (e) {
       console.error(`Failed to write config: ${e.message}`);
@@ -212,65 +263,20 @@ class CodexProvider extends BaseProvider {
     }
   }
 
-  parseTOML(content) {
-    // Simple TOML parser for [mcp_servers.*] sections
-    const servers = {};
-    const lines = content.split('\n');
-    let currentServer = null;
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (trimmed.startsWith('[mcp_servers.')) {
-        const match = trimmed.match(/\[mcp_servers\.([^\]]+)\]/);
-        if (match) {
-          currentServer = match[1];
-          servers[currentServer] = {};
-        }
-      } else if (currentServer && trimmed.includes('=')) {
-        const [key, ...valueParts] = trimmed.split('=');
-        const value = valueParts.join('=').trim();
-        if (key.trim() === 'command') {
-          servers[currentServer].command = value.replace(/"/g, '');
-        } else if (key.trim() === 'args') {
-          // Parse array: ["arg1", "arg2"]
-          const argsMatch = value.match(/\[(.*)\]/);
-          if (argsMatch) {
-            servers[currentServer].args = argsMatch[1]
-              .split(',')
-              .map(s => s.trim().replace(/"/g, ''));
-          }
-        }
-      }
-    }
-
-    return { mcp_servers: servers };
-  }
-
-  generateTOML(config) {
-    let toml = '';
-    const servers = config.mcp_servers || {};
-
-    for (const [name, serverConfig] of Object.entries(servers)) {
-      toml += `[mcp_servers.${name}]\n`;
-      toml += `command = "${serverConfig.command}"\n`;
-      if (serverConfig.args && serverConfig.args.length > 0) {
-        const argsStr = serverConfig.args.map(arg => `"${arg}"`).join(', ');
-        toml += `args = [${argsStr}]\n`;
-      }
-      toml += '\n';
-    }
-
-    return toml;
-  }
-
   configureMCP() {
     const config = this.readConfig() || { mcp_servers: {} };
-    config.mcp_servers.vault = {
+    config.mcp_servers.unifiedmemory = {
       command: "um",
       args: ["mcp", "serve"]
     };
     return this.writeConfig(config);
   }
+
+  configureMemoryInstructions() {
+    // Use project-level file
+    const instructionPath = path.join(process.cwd(), 'CODEX.md');
+    return this.writeMemoryInstructions(instructionPath, 'Codex CLI');
+  }
 }
 
 class GeminiProvider extends BaseProvider {
@@ -279,6 +285,12 @@ class GeminiProvider extends BaseProvider {
     const detectionPath = path.dirname(configPath); // Detect by directory
     super('Gemini CLI', configPath, false, detectionPath);
   }
+
+  configureMemoryInstructions() {
+    // Use project-level file
+    const instructionPath = path.join(process.cwd(), 'GEMINI.md');
+    return this.writeMemoryInstructions(instructionPath, 'Gemini CLI');
+  }
 }
 
 export {

package/lib/token-refresh.js

@@ -1,5 +1,6 @@
 import { getToken, saveToken } from './token-storage.js';
 import { config } from './config.js';
+import { parseJWT } from './jwt-utils.js';
 
 /**
  * Check if token has expired
@@ -93,21 +94,3 @@ export async function refreshAccessToken(tokenData) {
     throw new Error(`Token refresh failed: ${error.message}`);
   }
 }
-
-/**
- * Parse JWT token payload
- * @param {string} token - JWT token
- * @returns {Object|null} - Decoded payload
- */
-function parseJWT(token) {
-  try {
-    const parts = token.split('.');
-    if (parts.length !== 3) {
-      return null;
-    }
-    const payload = Buffer.from(parts[1], 'base64').toString('utf8');
-    return JSON.parse(payload);
-  } catch (error) {
-    return null;
-  }
-}

package/lib/token-storage.js

@@ -6,18 +6,24 @@ const TOKEN_DIR = path.join(os.homedir(), '.um');
 const TOKEN_FILE = path.join(TOKEN_DIR, 'auth.json');
 
 export function saveToken(tokenData) {
-  // Create directory if it doesn't exist
+  // Create directory if it doesn't exist (owner-only permissions)
   if (!fs.existsSync(TOKEN_DIR)) {
-    fs.mkdirSync(TOKEN_DIR, { recursive: true });
+    fs.mkdirSync(TOKEN_DIR, { recursive: true, mode: 0o700 });
   }
 
+  // Ensure directory permissions are correct (in case it was created with wrong permissions)
+  fs.chmodSync(TOKEN_DIR, 0o700);
+
   // Preserve existing organization context if not explicitly overwritten
   const existingData = getToken();
   if (existingData && existingData.selectedOrg && !tokenData.selectedOrg) {
     tokenData.selectedOrg = existingData.selectedOrg;
   }
 
+  // Write token file with owner-only read/write permissions (0600)
   fs.writeFileSync(TOKEN_FILE, JSON.stringify(tokenData, null, 2));
+  // Explicitly set file permissions (writeFileSync mode option doesn't always work with extended attributes)
+  fs.chmodSync(TOKEN_FILE, 0o600);
 }
 
 export function getToken() {
@@ -49,8 +55,15 @@ export function updateSelectedOrg(orgData) {
     throw new Error('No token found. Please login first.');
   }
 
+  // Ensure directory permissions are correct
+  if (fs.existsSync(TOKEN_DIR)) {
+    fs.chmodSync(TOKEN_DIR, 0o700);
+  }
+
   tokenData.selectedOrg = orgData;
+  // Write with owner-only read/write permissions (0600)
   fs.writeFileSync(TOKEN_FILE, JSON.stringify(tokenData, null, 2));
+  fs.chmodSync(TOKEN_FILE, 0o600);
 }
 
 /**

package/lib/welcome.js

@@ -0,0 +1,40 @@
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJson = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
+const version = packageJson.version;
+
+export function showWelcome() {
+  const pink = chalk.hex('#FF69B4');
+  const lightPink = chalk.hex('#FFB6C1');
+  const darkPink = chalk.hex('#C71585');
+  const gray = chalk.gray;
+  const white = chalk.white;
+
+  console.log('');
+  console.log(white.bold('  UnifiedMemory CLI ') + gray(`v${version}`));
+  console.log(gray('  AI-powered knowledge assistant'));
+  console.log('');
+  console.log(white('  Quick Start:'));
+  console.log(gray('    um init         ') + white('Initialize in current project'));
+  console.log(gray('    um status       ') + white('Check configuration'));
+  console.log(gray('    um login        ') + white('Authenticate with UnifiedMemory'));
+  console.log(gray('    um --help       ') + white('Show all commands'));
+  console.log('');
+  console.log(gray('  Learn more: ') + chalk.cyan.underline('https://unifiedmemory.ai'));
+  console.log('');
+}
+
+export function showShortWelcome() {
+  const pink = chalk.hex('#FF69B4');
+  const gray = chalk.gray;
+  const white = chalk.white;
+
+  console.log('');
+  console.log(pink('  🦎 ') + white.bold('UnifiedMemory CLI ') + gray(`v${version}`));
+  console.log(gray('     AI-powered knowledge assistant'));
+  console.log('');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unifiedmemory/cli",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "UnifiedMemory CLI - AI code assistant integration",
   "main": "index.js",
   "type": "module",
@@ -31,13 +31,15 @@
   },
   "homepage": "https://unifiedmemory.ai",
   "dependencies": {
+    "@iarna/toml": "^2.2.5",
     "@modelcontextprotocol/sdk": "^1.0.0",
+    "axios": "^1.6.2",
     "chalk": "^5.3.0",
     "commander": "^11.1.0",
+    "dotenv": "^16.6.1",
+    "fs-extra": "^11.2.0",
     "inquirer": "^13.0.1",
-    "open": "^10.0.3",
-    "axios": "^1.6.2",
-    "fs-extra": "^11.2.0"
+    "open": "^10.0.3"
   },
   "devDependencies": {
     "pkg": "^5.8.1"