@unifiedmemory/cli 1.3.1 → 1.3.7

package/.github/workflows/test-and-publish.yml

@@ -0,0 +1,96 @@
+name: Test and Publish
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [18, 20, 22]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm run test:ci
+        env:
+          CI: true
+
+      - name: Upload test results
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: test-results-node-${{ matrix.node-version }}
+          path: test-results.xml
+
+  publish:
+    needs: test
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          registry-url: 'https://registry.npmjs.org'
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Check if version changed
+        id: version-check
+        run: |
+          CURRENT_VERSION=$(node -p "require('./package.json').version")
+          NPM_VERSION=$(npm view @unifiedmemory/cli version 2>/dev/null || echo "0.0.0")
+          echo "current=$CURRENT_VERSION" >> $GITHUB_OUTPUT
+          echo "published=$NPM_VERSION" >> $GITHUB_OUTPUT
+          if [ "$CURRENT_VERSION" != "$NPM_VERSION" ]; then
+            echo "version_changed=true" >> $GITHUB_OUTPUT
+            echo "✅ Version changed: $NPM_VERSION → $CURRENT_VERSION"
+          else
+            echo "version_changed=false" >> $GITHUB_OUTPUT
+            echo "ℹ️ Version unchanged ($CURRENT_VERSION) - skipping publish"
+          fi
+
+      - name: Publish to npm
+        if: steps.version-check.outputs.version_changed == 'true'
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Create Git tag
+        if: steps.version-check.outputs.version_changed == 'true'
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          if ! git ls-remote --tags origin | grep -q "refs/tags/v${{ steps.version-check.outputs.current }}"; then
+            git tag v${{ steps.version-check.outputs.current }}
+            git push origin v${{ steps.version-check.outputs.current }}
+          else
+            echo "Tag v${{ steps.version-check.outputs.current }} already exists, skipping"
+          fi
+
+      - name: Skip publish notification
+        if: steps.version-check.outputs.version_changed == 'false'
+        run: |
+          echo "::notice::Skipped npm publish - version ${{ steps.version-check.outputs.current }} already published"

package/index.js

@@ -4,6 +4,9 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 import { login } from './commands/login.js';
 import { init } from './commands/init.js';
 import { switchOrg, showOrg } from './commands/org.js';
@@ -13,12 +16,15 @@ import { getSelectedOrg } from './lib/token-storage.js';
 import { loadAndRefreshToken } from './lib/token-validation.js';
 import { showWelcome } from './lib/welcome.js';
 
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageJson = JSON.parse(readFileSync(join(__dirname, 'package.json'), 'utf8'));
+
 const program = new Command();
 
 program
   .name('um')
   .description('UnifiedMemory CLI - AI code assistant integration')
-  .version('1.1.0');
+  .version(packageJson.version);
 
 // Unified command (primary)
 program
@@ -199,7 +205,7 @@ noteCommand
 
 // Show welcome splash if no command provided
 if (process.argv.length === 2) {
-  showWelcome();
+  await showWelcome();
   program.help();
 }
 

package/lib/welcome.js

@@ -2,22 +2,50 @@ import chalk from 'chalk';
 import { readFileSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
+import axios from 'axios';
 
 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 PACKAGE_NAME = '@unifiedmemory/cli';
+
+/**
+ * Check npm registry for latest version (non-blocking)
+ * @returns {Promise<{latest: string, isOutdated: boolean} | null>}
+ */
+export async function checkLatestVersion() {
+  try {
+    const response = await axios.get(
+      `https://registry.npmjs.org/${PACKAGE_NAME}/latest`,
+      { timeout: 2000 }
+    );
+    const latest = response.data.version;
+    const isOutdated = latest !== version;
+    return { latest, isOutdated };
+  } catch {
+    return null; // Silently fail - don't block CLI
+  }
+}
+
+export async function showWelcome() {
   const gray = chalk.gray;
   const white = chalk.white;
+  const yellow = chalk.yellow;
 
   console.log('');
   console.log(white.bold('  UnifiedMemory CLI ') + gray(`v${version}`));
   console.log(gray('  AI-powered knowledge assistant'));
   console.log('');
+
+  // Check for updates (non-blocking with short timeout)
+  const versionInfo = await checkLatestVersion();
+  if (versionInfo?.isOutdated) {
+    console.log(yellow('  ⚠ Update available: ') + white(`v${versionInfo.latest}`));
+    console.log(gray('    Run: ') + white('npm install -g @unifiedmemory/cli'));
+    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'));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unifiedmemory/cli",
-  "version": "1.3.1",
+  "version": "1.3.7",
   "description": "UnifiedMemory CLI - AI code assistant integration",
   "main": "index.js",
   "type": "module",
@@ -9,7 +9,13 @@
   },
   "scripts": {
     "start": "node index.js",
-    "build": "pkg . --targets node18-linux-x64,node18-macos-x64,node18-win-x64 --output dist/um"
+    "build": "pkg . --targets node18-linux-x64,node18-macos-x64,node18-win-x64 --output dist/um",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:unit": "vitest run tests/unit",
+    "test:integration": "vitest run tests/integration",
+    "test:ci": "vitest run --reporter=junit --outputFile=test-results.xml"
   },
   "keywords": [
     "ai",
@@ -42,10 +48,16 @@
     "open": "^10.0.3"
   },
   "devDependencies": {
-    "pkg": "^5.8.1"
+    "@vitest/coverage-v8": "^3.0.0",
+    "msw": "^2.7.0",
+    "pkg": "^5.8.1",
+    "vitest": "^3.0.0"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/unifiedmemory/um-cli.git"
+    "url": "https://github.com/Episodic-Solutions/um-cli.git"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/tests/fixtures/expired-auth.json

@@ -0,0 +1,20 @@
+{
+  "accessToken": "mock_expired_access_token",
+  "idToken": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyXzEyMzQ1Njc4OSIsImVtYWlsIjoidGVzdEB0ZXN0LmNvbSIsImV4cCI6MTYwMDAwMDAwMCwiaWF0IjoxNTk5OTk2NDAwLCJzaWQiOiJzZXNzXzEyMzQ1Njc4OSJ9.mock_signature",
+  "refresh_token": "mock_refresh_token_for_expired",
+  "tokenType": "Bearer",
+  "expiresIn": 3600,
+  "receivedAt": 1599996400000,
+  "decoded": {
+    "sub": "user_123456789",
+    "email": "test@test.com",
+    "exp": 1600000000,
+    "iat": 1599996400,
+    "sid": "sess_123456789"
+  },
+  "selectedOrg": {
+    "id": "org_456789012",
+    "name": "Test Organization",
+    "role": "admin"
+  }
+}

package/tests/fixtures/mock-auth.json

@@ -0,0 +1,21 @@
+{
+  "accessToken": "mock_access_token_abc123",
+  "idToken": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyXzEyMzQ1Njc4OSIsImVtYWlsIjoidGVzdEB0ZXN0LmNvbSIsImV4cCI6OTk5OTk5OTk5OSwiaWF0IjoxNjAwMDAwMDAwLCJzaWQiOiJzZXNzXzEyMzQ1Njc4OSIsIm9yZ19pZCI6Im9yZ180NTY3ODkwMTIifQ.mock_signature",
+  "refresh_token": "mock_refresh_token_xyz789",
+  "tokenType": "Bearer",
+  "expiresIn": 3600,
+  "receivedAt": 1700000000000,
+  "decoded": {
+    "sub": "user_123456789",
+    "email": "test@test.com",
+    "exp": 9999999999,
+    "iat": 1600000000,
+    "sid": "sess_123456789",
+    "org_id": "org_456789012"
+  },
+  "selectedOrg": {
+    "id": "org_456789012",
+    "name": "Test Organization",
+    "role": "admin"
+  }
+}

package/tests/fixtures/mock-project-config.json

@@ -0,0 +1,12 @@
+{
+  "version": "1.0",
+  "org_id": "org_456789012",
+  "project_id": "proj_987654321",
+  "project_name": "test-project",
+  "api_url": "https://api.test.unifiedmemory.ai",
+  "created_at": "2024-01-01T00:00:00.000Z",
+  "mcp_config": {
+    "inject_headers": true,
+    "auto_context": true
+  }
+}

package/tests/mocks/api.mock.js

@@ -0,0 +1,200 @@
+/**
+ * MSW (Mock Service Worker) handlers for API mocking
+ *
+ * These handlers intercept HTTP requests during tests and return
+ * predefined responses without hitting real APIs.
+ */
+
+import { http, HttpResponse } from 'msw';
+
+const API_BASE_URL = 'https://rose-asp-main-1c0b114.d2.zuplo.dev';
+
+// Sample project data
+const mockProjects = [
+  {
+    id: 'proj_001',
+    name: 'project-one',
+    display_name: 'Project One',
+    slug: 'project-one',
+    description: 'First test project',
+    created_at: '2024-01-01T00:00:00.000Z',
+  },
+  {
+    id: 'proj_002',
+    name: 'project-two',
+    display_name: 'Project Two',
+    slug: 'project-two',
+    description: 'Second test project',
+    created_at: '2024-01-02T00:00:00.000Z',
+  },
+];
+
+// Sample MCP tools data
+const mockMCPTools = [
+  {
+    name: 'create_note',
+    description: 'Create a new note in the vault',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        content: { type: 'string', description: 'Note content' },
+        pathParams: {
+          type: 'object',
+          properties: {
+            org: { type: 'string' },
+            proj: { type: 'string' },
+          },
+          required: ['org', 'proj'],
+        },
+        headers: {
+          type: 'object',
+          properties: {
+            'X-Org-Id': { type: 'string' },
+          },
+        },
+      },
+      required: ['content', 'pathParams'],
+    },
+  },
+  {
+    name: 'search_notes',
+    description: 'Search notes in the vault',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Search query' },
+        pathParams: {
+          type: 'object',
+          properties: {
+            org: { type: 'string' },
+            proj: { type: 'string' },
+          },
+          required: ['org', 'proj'],
+        },
+      },
+      required: ['query', 'pathParams'],
+    },
+  },
+];
+
+/**
+ * Default API handlers for common endpoints
+ */
+export const handlers = [
+  // GET /v1/orgs/:org/projects - List projects
+  http.get(`${API_BASE_URL}/v1/orgs/:org/projects`, ({ request, params }) => {
+    const authHeader = request.headers.get('Authorization');
+
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+      return HttpResponse.json(
+        { error: 'Unauthorized', message: 'Missing or invalid authorization header' },
+        { status: 401 }
+      );
+    }
+
+    return HttpResponse.json({ items: mockProjects });
+  }),
+
+  // POST /v1/orgs/:org/projects - Create project
+  http.post(`${API_BASE_URL}/v1/orgs/:org/projects`, async ({ request, params }) => {
+    const authHeader = request.headers.get('Authorization');
+
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+      return HttpResponse.json(
+        { error: 'Unauthorized', message: 'Missing or invalid authorization header' },
+        { status: 401 }
+      );
+    }
+
+    const body = await request.json();
+
+    return HttpResponse.json({
+      id: `proj_${Date.now()}`,
+      name: body.display_name.toLowerCase().replace(/\s+/g, '-'),
+      display_name: body.display_name,
+      slug: body.display_name.toLowerCase().replace(/\s+/g, '-'),
+      description: body.description || '',
+      created_at: new Date().toISOString(),
+    });
+  }),
+
+  // POST /mcp - MCP endpoint for tools/list
+  http.post(`${API_BASE_URL}/mcp`, async ({ request }) => {
+    const body = await request.json();
+
+    if (body.method === 'tools/list') {
+      return HttpResponse.json({
+        jsonrpc: '2.0',
+        id: body.id,
+        result: {
+          tools: mockMCPTools,
+        },
+      });
+    }
+
+    if (body.method === 'tools/call') {
+      return HttpResponse.json({
+        jsonrpc: '2.0',
+        id: body.id,
+        result: {
+          content: [
+            {
+              type: 'text',
+              text: `Tool ${body.params.name} executed successfully`,
+            },
+          ],
+        },
+      });
+    }
+
+    return HttpResponse.json(
+      {
+        jsonrpc: '2.0',
+        id: body.id,
+        error: { code: -32601, message: 'Method not found' },
+      },
+      { status: 400 }
+    );
+  }),
+
+  // GET /health - Health check
+  http.get(`${API_BASE_URL}/health`, () => {
+    return HttpResponse.json({ status: 'healthy' });
+  }),
+];
+
+/**
+ * Handler that returns 401 for all requests (unauthorized)
+ */
+export const unauthorizedHandlers = [
+  http.all(`${API_BASE_URL}/*`, () => {
+    return HttpResponse.json(
+      { error: 'Unauthorized', message: 'Token expired or invalid' },
+      { status: 401 }
+    );
+  }),
+];
+
+/**
+ * Handler that returns 500 for all requests (server error)
+ */
+export const serverErrorHandlers = [
+  http.all(`${API_BASE_URL}/*`, () => {
+    return HttpResponse.json(
+      { error: 'Internal Server Error', message: 'Something went wrong' },
+      { status: 500 }
+    );
+  }),
+];
+
+/**
+ * Handler that simulates network failure
+ */
+export const networkErrorHandlers = [
+  http.all(`${API_BASE_URL}/*`, () => {
+    return HttpResponse.error();
+  }),
+];
+
+// Export mock data for use in tests
+export { mockProjects, mockMCPTools };

package/tests/mocks/token-storage.mock.js

@@ -0,0 +1,79 @@
+/**
+ * Mock for token-storage.js
+ *
+ * Provides mock implementations of token storage functions
+ * that don't interact with the real filesystem.
+ */
+
+import { vi } from 'vitest';
+import mockAuthData from '../fixtures/mock-auth.json' with { type: 'json' };
+import expiredAuthData from '../fixtures/expired-auth.json' with { type: 'json' };
+
+/**
+ * Creates a mock token storage module with configurable behavior
+ * @param {Object} options - Configuration options
+ * @param {Object|null} options.initialToken - Initial token data to return (use null for no token)
+ * @param {boolean} options.expired - Whether to use expired token fixture
+ * @param {boolean} options.empty - Whether to start with no token
+ * @returns {Object} Mock token storage functions
+ */
+export function createTokenStorageMock(options = {}) {
+  let tokenData;
+
+  if (options.empty) {
+    tokenData = null;
+  } else if (options.expired) {
+    tokenData = { ...expiredAuthData };
+  } else if (options.initialToken !== undefined) {
+    tokenData = options.initialToken;
+  } else {
+    tokenData = { ...mockAuthData };
+  }
+
+  return {
+    saveToken: vi.fn((data) => {
+      tokenData = data;
+    }),
+
+    getToken: vi.fn(() => tokenData),
+
+    clearToken: vi.fn(() => {
+      tokenData = null;
+    }),
+
+    updateSelectedOrg: vi.fn((orgData) => {
+      if (tokenData) {
+        tokenData.selectedOrg = orgData;
+      } else {
+        throw new Error('No token found. Please login first.');
+      }
+    }),
+
+    getSelectedOrg: vi.fn(() => tokenData?.selectedOrg || null),
+
+    // Helper to reset state between tests
+    _reset: (newData = null) => {
+      tokenData = newData ?? { ...mockAuthData };
+    },
+
+    // Helper to get current state for assertions
+    _getState: () => tokenData,
+  };
+}
+
+/**
+ * Creates mock token storage that returns null (no token)
+ */
+export function createEmptyTokenStorageMock() {
+  return createTokenStorageMock({ empty: true });
+}
+
+/**
+ * Creates mock token storage with expired token
+ */
+export function createExpiredTokenStorageMock() {
+  return createTokenStorageMock({ expired: true });
+}
+
+// Export fixtures for direct use in tests
+export { mockAuthData, expiredAuthData };

package/tests/setup.js

@@ -0,0 +1,29 @@
+/**
+ * Vitest Global Test Setup
+ *
+ * This file runs before all tests and sets up the test environment.
+ * It configures mocks and ensures tests don't interact with real auth.
+ */
+
+import { vi, beforeAll, afterAll, afterEach } from 'vitest';
+
+// Ensure we're in test mode
+process.env.NODE_ENV = 'test';
+
+// Mock console.error to reduce noise in tests (optional)
+// Uncomment if you want to suppress console output during tests:
+// vi.spyOn(console, 'error').mockImplementation(() => {});
+// vi.spyOn(console, 'log').mockImplementation(() => {});
+
+beforeAll(() => {
+  // Global setup before all tests
+});
+
+afterEach(() => {
+  // Clean up mocks after each test
+  vi.restoreAllMocks();
+});
+
+afterAll(() => {
+  // Global cleanup after all tests
+});