@unifiedmemory/cli 1.3.1 → 1.3.6

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

@@ -0,0 +1,92 @@
+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"
+          git tag v${{ steps.version-check.outputs.current }}
+          git push origin v${{ steps.version-check.outputs.current }}
+
+      - 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unifiedmemory/cli",
-  "version": "1.3.1",
+  "version": "1.3.6",
   "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
+});

package/tests/unit/config.test.js

@@ -0,0 +1,165 @@
+/**
+ * Unit tests for lib/config.js
+ *
+ * Tests configuration loading and validation.
+ * Note: The config module loads environment variables at import time,
+ * so we test the validateConfig function and config structure.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+describe('config', () => {
+  // Store original env vars
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    // Reset modules to get fresh config import
+    vi.resetModules();
+  });
+
+  afterEach(() => {
+    // Restore original environment
+    process.env = { ...originalEnv };
+    vi.resetModules();
+  });
+
+  describe('default configuration', () => {
+    it('should have default values when no environment variables are set', async () => {
+      // Clear relevant env vars
+      delete process.env.CLERK_CLIENT_ID;
+      delete process.env.CLERK_DOMAIN;
+      delete process.env.API_ENDPOINT;
+      delete process.env.REDIRECT_URI;
+      delete process.env.PORT;
+
+      // Fresh import to get defaults
+      const { config } = await import('../../lib/config.js');
+
+      expect(config.clerkClientId).toBe('nULlnomaKB9rRGP2');
+      expect(config.clerkDomain).toBe('clear-caiman-45.clerk.accounts.dev');
+      expect(config.apiEndpoint).toBe('https://rose-asp-main-1c0b114.d2.zuplo.dev');
+      expect(config.redirectUri).toBe('http://localhost:3333/callback');
+      expect(config.port).toBe(3333);
+    });
+
+    it('should have clerkClientSecret as undefined by default', async () => {
+      delete process.env.CLERK_CLIENT_SECRET;
+
+      const { config } = await import('../../lib/config.js');
+
+      expect(config.clerkClientSecret).toBeUndefined();
+    });
+  });
+
+  describe('environment variable overrides', () => {
+    it('should use CLERK_CLIENT_ID from environment', async () => {
+      process.env.CLERK_CLIENT_ID = 'custom_client_id';
+
+      const { config } = await import('../../lib/config.js');
+
+      expect(config.clerkClientId).toBe('custom_client_id');
+    });
+
+    it('should use CLERK_DOMAIN from environment', async () => {
+      process.env.CLERK_DOMAIN = 'custom.clerk.dev';
+
+      const { config } = await import('../../lib/config.js');
+
+      expect(config.clerkDomain).toBe('custom.clerk.dev');
+    });
+
+    it('should use API_ENDPOINT from environment', async () => {
+      process.env.API_ENDPOINT = 'https://custom-api.example.com';
+
+      const { config } = await import('../../lib/config.js');
+
+      expect(config.apiEndpoint).toBe('https://custom-api.example.com');
+    });
+
+    it('should use REDIRECT_URI from environment', async () => {
+      process.env.REDIRECT_URI = 'http://localhost:8080/callback';
+
+      const { config } = await import('../../lib/config.js');
+
+      expect(config.redirectUri).toBe('http://localhost:8080/callback');
+    });
+
+    it('should use PORT from environment and parse as integer', async () => {
+      process.env.PORT = '8080';
+
+      const { config } = await import('../../lib/config.js');
+
+      expect(config.port).toBe(8080);
+      expect(typeof config.port).toBe('number');
+    });
+
+    it('should use CLERK_CLIENT_SECRET from environment', async () => {
+      process.env.CLERK_CLIENT_SECRET = 'secret_key_123';
+
+      const { config } = await import('../../lib/config.js');
+
+      expect(config.clerkClientSecret).toBe('secret_key_123');
+    });
+  });
+
+  describe('validateConfig', () => {
+    it('should return true for valid default configuration', async () => {
+      const { validateConfig } = await import('../../lib/config.js');
+
+      expect(validateConfig()).toBe(true);
+    });
+
+    it('should throw error for invalid API_ENDPOINT URL', async () => {
+      process.env.API_ENDPOINT = 'not-a-valid-url';
+
+      const { validateConfig } = await import('../../lib/config.js');
+
+      expect(() => validateConfig()).toThrow('API_ENDPOINT must be a valid URL');
+    });
+
+    it('should use default when CLERK_DOMAIN is empty (falsy falls back to default)', async () => {
+      process.env.CLERK_DOMAIN = '';
+
+      const { config, validateConfig } = await import('../../lib/config.js');
+
+      // Empty string is falsy, so it falls back to default
+      expect(config.clerkDomain).toBe('clear-caiman-45.clerk.accounts.dev');
+      expect(validateConfig()).toBe(true);
+    });
+
+    it('should throw error when CLERK_DOMAIN is whitespace only', async () => {
+      // Whitespace is truthy, so it will be used instead of default
+      process.env.CLERK_DOMAIN = '   ';
+
+      const { validateConfig } = await import('../../lib/config.js');
+
+      expect(() => validateConfig()).toThrow('CLERK_DOMAIN cannot be empty');
+    });
+
+    it('should use default when CLERK_CLIENT_ID is empty (falsy falls back to default)', async () => {
+      process.env.CLERK_CLIENT_ID = '';
+
+      const { config, validateConfig } = await import('../../lib/config.js');
+
+      // Empty string is falsy, so it falls back to default
+      expect(config.clerkClientId).toBe('nULlnomaKB9rRGP2');
+      expect(validateConfig()).toBe(true);
+    });
+
+    it('should accept valid HTTPS URL for API_ENDPOINT', async () => {
+      process.env.API_ENDPOINT = 'https://api.example.com/v1';
+
+      const { validateConfig } = await import('../../lib/config.js');
+
+      expect(validateConfig()).toBe(true);
+    });
+
+    it('should accept valid HTTP URL for API_ENDPOINT (development)', async () => {
+      process.env.API_ENDPOINT = 'http://localhost:8000';
+
+      const { validateConfig } = await import('../../lib/config.js');
+
+      expect(validateConfig()).toBe(true);
+    });
+  });
+});