memos-mcp 1.0.1 → 1.0.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "memos-mcp",
   "type": "module",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "MCP server for Memos - create and search memos",
   "main": "src/index.ts",
   "bin": {

package/.vscode/settings.json

@@ -1,19 +0,0 @@
-{
-  "[typescript]": {
-    "editor.formatOnSave": true,
-    "editor.formatOnSaveMode": "file"
-  },
-  "editor.formatOnSave": true,
-  "editor.formatOnSaveMode": "file",
-  "editor.codeActionsOnSave": {
-    "source.fixAll.biome": "explicit",
-    "source.organizeImports.biome": "explicit"
-  },
-  "editor.defaultFormatter": "esbenp.prettier-vscode",
-  "nodejs-testing.extensions": [
-    {
-      "extensions": ["mjs", "cjs", "js", "ts"],
-      "parameters": []
-    }
-  ]
-}

package/AGENTS.md

@@ -1,96 +0,0 @@
-# Agent Guidelines for memos-mcp
-
-## Overview
-
-This is an MCP (Model Context Protocol) server for Memos - a lightweight, self-hosted memo hub. The server provides tools to create and search memos via the Memos API.
-
-## Required Checks Before Committing
-
-**IMPORTANT:** Always run these commands before committing changes:
-
-```bash
-# 1. Type checking - REQUIRED
-npm run typecheck
-
-# 2. Linting - REQUIRED
-npm run lint
-
-# 3. Format check - REQUIRED
-npm run format:check
-
-# 4. Tests - REQUIRED
-npm run test
-```
-
-All checks must pass before committing. You can auto-fix lint and format issues:
-
-```bash
-npm run lint:fix    # Auto-fix lint issues
-npm run format      # Auto-format code
-```
-
-## Project Structure
-
-```
-src/
-├── index.ts              # MCP server entry point
-├── memos-client.ts       # Memos API client
-├── memos-client.test.ts  # Client tests
-├── cert-manager.ts       # SSL certificate auto-fetch & cache
-└── cert-manager.test.ts  # Cert manager tests
-```
-
-## Key Technical Details
-
-### SSL Certificate Handling
-
-The project includes automatic SSL certificate management for servers with incomplete certificate chains (missing intermediates). See `cert-manager.ts`:
-
-- Auto-fetches Let's Encrypt intermediate certificates via HTTPS
-- Caches certificates in `~/.cache/memos-mcp/certs/`
-- Auto-refreshes when cache > 30 days or cert expires within 30 days
-
-### Dependencies
-
-- `@modelcontextprotocol/sdk` - MCP SDK for server implementation
-- `undici` - HTTP client with custom TLS agent support
-
-### Node.js Version
-
-Requires Node.js >= 22.0.0
-
-## Code Style
-
-- Uses Prettier for formatting (config in package.json)
-- Uses ESLint with TypeScript plugin
-- Double quotes for strings
-- Semicolons required
-- 120 character line width
-
-## Testing
-
-Tests use Node.js built-in test runner (`node:test`):
-
-```bash
-npm run test
-```
-
-Integration tests in `cert-manager.test.ts` make real network requests to Let's Encrypt servers.
-
-## Common Tasks
-
-### Adding a new MCP tool
-
-1. Add tool definition in `src/index.ts` under `server.setRequestHandler(ListToolsRequestSchema, ...)`
-2. Add tool handler in `server.setRequestHandler(CallToolRequestSchema, ...)`
-3. Implement the method in `src/memos-client.ts`
-4. Add tests in `src/memos-client.test.ts`
-
-### Updating certificates
-
-Certificates are auto-fetched, but you can force refresh:
-
-```typescript
-import { refreshAllCerts } from "./cert-manager.ts";
-await refreshAllCerts();
-```

package/Jenkinsfile

@@ -1,80 +0,0 @@
-pipeline {
-  agent any
-  tools {
-    nodejs 'NodeJS 24.x'
-  }
-  stages {
-    stage('Checkout') {
-      steps {
-        checkout scm
-      }
-    }
-
-    stage('Install') {
-      steps {
-        script {
-          sh 'npm i'
-        }
-      }
-    }
-
-    stage('Lint') {
-      steps {
-        script {
-          sh 'npm run lint --if-present'
-          sh 'npm run format:check --if-present'
-        }
-      }
-    }
-
-    stage('Test') {
-      steps {
-        script {
-          sh 'npm test --if-present'
-        }
-      }
-    }
-
-    stage('Build') {
-      steps {
-        script {
-          sh 'npm run build --if-present'
-        }
-      }
-    }
-
-    stage('Publish Official Release') {
-      when {
-        expression { env.TAG_NAME != null } // Only run for tag builds
-      }
-      environment {
-          NPM_TOKEN = credentials('npm-verdaccio-publish-token')
-      }
-      steps {
-          sh 'npm config set //verdaccio-verdaccio-68mj54-e6081a-192-168-111-123.traefik.me/:_authToken=${NPM_TOKEN} --location project'
-          sh 'npm publish --tag latest'
-      }
-    }
-
-    // stage('Publish Snapshot Build') {
-    //   when {
-    //     expression { env.TAG_NAME == null } // Only run for non-tag builds
-    //   }
-    //   environment {
-    //       NPM_TOKEN = credentials('npm-verdaccio-publish-token')
-    //   }
-    //   steps {
-    //       sh 'npm config set //verdaccio-verdaccio-68mj54-e6081a-192-168-111-123.traefik.me/:_authToken=${NPM_TOKEN} --location project'
-    //       sh 'npm version 0.0.0-BUILD-${BUILD_NUMBER} --no-git-tag-version' // Apply snapshot version
-    //       sh 'npm publish --tag snapshot' // Publish with snapshot tag
-    //   }
-    // }
-
-  }
-
-  post {
-    always {
-      cleanWs()
-    }
-  }
-}

package/RELEASE.md

@@ -1,25 +0,0 @@
-## Release Process
-
-This project uses a two-pronged release approach:
-
-### Official Releases (Versioned)
-
-Official releases follow Semantic Versioning (MAJOR.MINOR.PATCH) and are published to npm with the `latest` tag.
-
-**Steps for a Developer to Create an Official Release:**
-
-1.  **Ensure your local `main` branch is up-to-date** and all changes intended for the release are merged.
-2.  **Run `npm version <patch|minor|major>` locally.** This command will:
-    - Increment the version in `package.json`.
-    - Create a git commit for the version change.
-    - Create a corresponding local git tag (e.g., `v1.0.0`).
-    - Example: `npm version patch`
-3.  **Push the commit and the new tag to the remote repository:**
-    ```bash
-    git push && git push --tags
-    ```
-4.  **Jenkins will automatically detect the new tag** and trigger a pipeline build. The `Publish Official Release` stage in the `Jenkinsfile` will then publish the package to npm with the `latest` tag.
-
-### Snapshot Builds
-
-For builds on branches that are not triggered by a git tag (e.g., `main` branch builds from regular commits), a snapshot version is automatically applied and published to npm with a `snapshot` tag. These builds are primarily for continuous integration and testing purposes and do not represent official releases.

package/eslint.config.js

@@ -1,34 +0,0 @@
-// eslint.config.js
-import js from "@eslint/js";
-import typescript from "@typescript-eslint/eslint-plugin";
-import typescriptParser from "@typescript-eslint/parser";
-import prettier from "eslint-plugin-prettier";
-import prettierConfig from "eslint-config-prettier";
-import globals from "globals";
-
-export default [
-  js.configs.recommended,
-  {
-    files: ["**/*.{js,mjs,cjs,ts,tsx}"],
-    languageOptions: {
-      ecmaVersion: "latest",
-      sourceType: "module",
-      parser: typescriptParser,
-      globals: {
-        ...globals.node,
-        RequestInit: "readonly",
-      },
-    },
-    plugins: {
-      "@typescript-eslint": typescript,
-      prettier: prettier,
-    },
-    rules: {
-      ...typescript.configs.recommended.rules,
-      ...prettierConfig.rules,
-      "prettier/prettier": "error",
-      "no-unused-vars": "off",
-      "@typescript-eslint/no-unused-vars": "error",
-    },
-  },
-];

package/memory.md

@@ -1,51 +0,0 @@
-# Memory
-
-## Project Purpose
-
-This project appears to be a TypeScript project template, providing a basic setup for developing and testing TypeScript code. It includes a simple `add` function and a corresponding unit test.
-
-## Project Structure
-
-- `.gitignore`: Specifies intentionally untracked files to ignore.
-- `eslint.config.js`: ESLint configuration for linting TypeScript files.
-- `Jenkinsfile`: Likely a Jenkins pipeline definition for CI/CD.
-- `package-lock.json`: Records the exact dependency tree.
-- `package.json`: Project metadata, scripts, and dependencies.
-- `README.md`: Project README file.
-- `RELEASE.md`: Release notes or guidelines.
-- `src/`: Source code directory.
-  - `src/index.ts`: Contains the main application logic (currently a simple `add` function).
-- `test/`: Test code directory.
-  - `test/index.test.ts`: Contains unit tests for `src/index.ts`.
-
-## Project Technical Details
-
-### Technical Stack
-
-- **Language**: Node.js Native TypeScript (means not compiler required and must import module with `.ts`/`.js` suffix)
-- **Runtime**: Node.js
-- **Linting**: ESLint with `@typescript-eslint/eslint-plugin` and `@typescript-eslint/parser`
-- **Formatting**: Prettier with `eslint-config-prettier` and `eslint-plugin-prettier`
-- **Testing**: Node.js built-in test runner (`node --test`)
-
-### Important Dependent Libraries
-
-- `@types/node`: Type definitions for Node.js.
-- `@typescript-eslint/eslint-plugin`: ESLint plugin for TypeScript.
-- `@typescript-eslint/parser`: Parser for ESLint to understand TypeScript.
-- `eslint`: Linter.
-- `eslint-config-prettier`: Disables ESLint rules that conflict with Prettier.
-- `eslint-plugin-prettier`: Runs Prettier as an ESLint rule.
-- `prettier`: Code formatter.
-
-## Features Implemented
-
-- A basic `add` function in `src/index.ts`.
-- A unit test for the `add` function in `test/index.test.ts`.
-- Linting and formatting configurations.
-- A test script using Node.js's built-in test runner.
-
-## Design Patterns
-
-- **Modular Design**: The `add` function is exported from `index.ts` and imported into `index.test.ts`, demonstrating modularity.
-- **Unit Testing**: The project includes a dedicated test file and uses a unit testing framework to verify the correctness of the `add` function.

package/src/cert-manager.test.ts

@@ -1,322 +0,0 @@
-/**
- * Tests for Certificate Manager
- */
-
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert";
-import { existsSync, mkdirSync, writeFileSync, unlinkSync, readFileSync } from "node:fs";
-import path from "node:path";
-import os from "node:os";
-import {
-  getAllIntermediateCerts,
-  getIntermediateCerts,
-  refreshAllCerts,
-  clearCache,
-  getCacheStatus,
-} from "./cert-manager.ts";
-
-// Test cache directory (same as in cert-manager.ts)
-const CERT_CACHE_DIR = path.join(os.homedir(), ".cache", "memos-mcp", "certs");
-const CACHE_FILE = path.join(CERT_CACHE_DIR, "cert-cache.json");
-
-describe("CertManager", () => {
-  // Store original cache if exists
-  let originalCache: string | null = null;
-
-  beforeEach(() => {
-    // Backup original cache if it exists (sync for beforeEach)
-    if (existsSync(CACHE_FILE)) {
-      originalCache = readFileSync(CACHE_FILE, "utf-8");
-    }
-  });
-
-  afterEach(async () => {
-    // Restore original cache
-    if (originalCache) {
-      writeFileSync(CACHE_FILE, originalCache);
-    } else if (existsSync(CACHE_FILE)) {
-      // If there was no original cache, remove the test one
-      unlinkSync(CACHE_FILE);
-    }
-    originalCache = null;
-  });
-
-  describe("clearCache", () => {
-    it("should remove the cache file", async () => {
-      // Ensure cache exists first
-      if (!existsSync(CERT_CACHE_DIR)) {
-        mkdirSync(CERT_CACHE_DIR, { recursive: true });
-      }
-      writeFileSync(CACHE_FILE, JSON.stringify({ version: 1, certs: {} }));
-
-      await clearCache();
-
-      assert.strictEqual(existsSync(CACHE_FILE), false);
-    });
-
-    it("should not throw if cache file does not exist", async () => {
-      // Ensure cache doesn't exist
-      if (existsSync(CACHE_FILE)) {
-        unlinkSync(CACHE_FILE);
-      }
-
-      await assert.doesNotReject(async () => await clearCache());
-    });
-  });
-
-  describe("getCacheStatus", () => {
-    it("should return empty object when cache is empty", async () => {
-      await clearCache();
-
-      const status = await getCacheStatus();
-
-      assert.deepStrictEqual(status, {});
-    });
-
-    it("should return status for cached certificates", async () => {
-      // Clear in-memory cache first so it reloads from file
-      await clearCache();
-
-      // Create a mock cache
-      const mockCache = {
-        version: 1,
-        certs: {
-          E8: {
-            pem: "-----BEGIN CERTIFICATE-----\ntest\n-----END CERTIFICATE-----",
-            fetchedAt: Date.now(),
-            expiresAt: Date.now() + 365 * 24 * 60 * 60 * 1000, // 1 year from now
-          },
-        },
-      };
-
-      if (!existsSync(CERT_CACHE_DIR)) {
-        mkdirSync(CERT_CACHE_DIR, { recursive: true });
-      }
-      writeFileSync(CACHE_FILE, JSON.stringify(mockCache));
-
-      const status = await getCacheStatus();
-
-      assert.ok(status.E8);
-      assert.ok(status.E8.fetchedAt instanceof Date);
-      assert.ok(status.E8.expiresAt instanceof Date);
-      assert.strictEqual(typeof status.E8.needsRefresh, "boolean");
-    });
-
-    it("should indicate needsRefresh for old cache entries", async () => {
-      // Clear in-memory cache first so it reloads from file
-      await clearCache();
-
-      // Create an old cache entry (40 days ago)
-      const fortyDaysAgo = Date.now() - 40 * 24 * 60 * 60 * 1000;
-      const mockCache = {
-        version: 1,
-        certs: {
-          E8: {
-            pem: "-----BEGIN CERTIFICATE-----\ntest\n-----END CERTIFICATE-----",
-            fetchedAt: fortyDaysAgo,
-            expiresAt: Date.now() + 365 * 24 * 60 * 60 * 1000,
-          },
-        },
-      };
-
-      if (!existsSync(CERT_CACHE_DIR)) {
-        mkdirSync(CERT_CACHE_DIR, { recursive: true });
-      }
-      writeFileSync(CACHE_FILE, JSON.stringify(mockCache));
-
-      const status = await getCacheStatus();
-
-      assert.strictEqual(status.E8.needsRefresh, true);
-    });
-
-    it("should indicate needsRefresh for soon-to-expire certificates", async () => {
-      // Clear in-memory cache first so it reloads from file
-      await clearCache();
-
-      // Create a cache entry that expires in 20 days
-      const twentyDaysFromNow = Date.now() + 20 * 24 * 60 * 60 * 1000;
-      const mockCache = {
-        version: 1,
-        certs: {
-          E8: {
-            pem: "-----BEGIN CERTIFICATE-----\ntest\n-----END CERTIFICATE-----",
-            fetchedAt: Date.now(),
-            expiresAt: twentyDaysFromNow,
-          },
-        },
-      };
-
-      if (!existsSync(CERT_CACHE_DIR)) {
-        mkdirSync(CERT_CACHE_DIR, { recursive: true });
-      }
-      writeFileSync(CACHE_FILE, JSON.stringify(mockCache));
-
-      const status = await getCacheStatus();
-
-      assert.strictEqual(status.E8.needsRefresh, true);
-    });
-  });
-
-  describe("getIntermediateCerts", () => {
-    it("should return empty array for unknown certificate names", async () => {
-      const result = await getIntermediateCerts(["UNKNOWN_CERT"]);
-
-      assert.deepStrictEqual(result, []);
-    });
-
-    it("should return cached certificate if available and fresh", async () => {
-      // Clear in-memory cache first so it reloads from file
-      await clearCache();
-
-      // Create a fresh cache
-      const mockCache = {
-        version: 1,
-        certs: {
-          E8: {
-            pem: "-----BEGIN CERTIFICATE-----\nMOCK_E8_CERT\n-----END CERTIFICATE-----",
-            fetchedAt: Date.now(),
-            expiresAt: Date.now() + 365 * 24 * 60 * 60 * 1000,
-          },
-        },
-      };
-
-      if (!existsSync(CERT_CACHE_DIR)) {
-        mkdirSync(CERT_CACHE_DIR, { recursive: true });
-      }
-      writeFileSync(CACHE_FILE, JSON.stringify(mockCache));
-
-      const result = await getIntermediateCerts(["E8"]);
-
-      assert.ok(result.length === 1);
-      assert.ok(result[0].includes("MOCK_E8_CERT"));
-    });
-
-    it("should return multiple certificates when requested", async () => {
-      // Clear in-memory cache first so it reloads from file
-      await clearCache();
-
-      // Create cache with multiple certs
-      const mockCache = {
-        version: 1,
-        certs: {
-          E8: {
-            pem: "-----BEGIN CERTIFICATE-----\nMOCK_E8\n-----END CERTIFICATE-----",
-            fetchedAt: Date.now(),
-            expiresAt: Date.now() + 365 * 24 * 60 * 60 * 1000,
-          },
-          R3: {
-            pem: "-----BEGIN CERTIFICATE-----\nMOCK_R3\n-----END CERTIFICATE-----",
-            fetchedAt: Date.now(),
-            expiresAt: Date.now() + 365 * 24 * 60 * 60 * 1000,
-          },
-        },
-      };
-
-      if (!existsSync(CERT_CACHE_DIR)) {
-        mkdirSync(CERT_CACHE_DIR, { recursive: true });
-      }
-      writeFileSync(CACHE_FILE, JSON.stringify(mockCache));
-
-      const result = await getIntermediateCerts(["E8", "R3"]);
-
-      assert.strictEqual(result.length, 2);
-      assert.ok(result.some((c) => c.includes("MOCK_E8")));
-      assert.ok(result.some((c) => c.includes("MOCK_R3")));
-    });
-  });
-
-  describe("getAllIntermediateCerts (integration)", () => {
-    it("should fetch and cache certificates from Let's Encrypt", async () => {
-      // Clear cache first
-      await clearCache();
-
-      // This is an integration test - it actually fetches from the network
-      const certs = await getAllIntermediateCerts();
-
-      // Should have fetched at least some certificates
-      assert.ok(certs.length > 0, "Should have fetched certificates");
-      assert.ok(
-        certs.some((c) => c.includes("-----BEGIN CERTIFICATE-----")),
-        "Should contain PEM certificates",
-      );
-
-      // Check cache was populated
-      const status = await getCacheStatus();
-      const cachedCerts = Object.keys(status);
-      assert.ok(cachedCerts.length > 0, "Should have cached certificates");
-    });
-  });
-
-  describe("refreshAllCerts (integration)", () => {
-    it("should refresh all certificates", async () => {
-      // Clear cache first
-      await clearCache();
-
-      // Refresh all certs
-      await refreshAllCerts();
-
-      // Check cache was populated
-      const status = await getCacheStatus();
-      const cachedCerts = Object.keys(status);
-
-      // Should have cached multiple certificates
-      assert.ok(cachedCerts.length >= 5, `Expected at least 5 certs, got ${cachedCerts.length}`);
-
-      // All should have been recently fetched
-      const now = Date.now();
-      for (const [name, info] of Object.entries(status)) {
-        const fetchedAge = now - info.fetchedAt.getTime();
-        // Should have been fetched within the last minute
-        assert.ok(fetchedAge < 60000, `${name} should have been fetched recently, age: ${fetchedAge}ms`);
-      }
-    });
-  });
-
-  describe("cache persistence", () => {
-    it("should persist cache across calls", async () => {
-      // Clear in-memory cache first so it reloads from file
-      await clearCache();
-
-      // Create initial cache
-      const mockCache = {
-        version: 1,
-        certs: {
-          TEST: {
-            pem: "-----BEGIN CERTIFICATE-----\nTEST_PERSIST\n-----END CERTIFICATE-----",
-            fetchedAt: Date.now(),
-            expiresAt: Date.now() + 365 * 24 * 60 * 60 * 1000,
-          },
-        },
-      };
-
-      if (!existsSync(CERT_CACHE_DIR)) {
-        mkdirSync(CERT_CACHE_DIR, { recursive: true });
-      }
-      writeFileSync(CACHE_FILE, JSON.stringify(mockCache));
-
-      // Read status - this loads the cache
-      const status1 = await getCacheStatus();
-      assert.ok(status1.TEST);
-
-      // Read again - should still have the same data
-      const status2 = await getCacheStatus();
-      assert.ok(status2.TEST);
-      assert.strictEqual(status1.TEST.fetchedAt.getTime(), status2.TEST.fetchedAt.getTime());
-    });
-
-    it("should handle corrupted cache gracefully", async () => {
-      // Clear in-memory cache first so it reloads from file
-      await clearCache();
-
-      // Write corrupted cache
-      if (!existsSync(CERT_CACHE_DIR)) {
-        mkdirSync(CERT_CACHE_DIR, { recursive: true });
-      }
-      writeFileSync(CACHE_FILE, "not valid json {{{");
-
-      // Should not throw, should return empty
-      const status = await getCacheStatus();
-      assert.deepStrictEqual(status, {});
-    });
-  });
-});

package/src/memos-client.test.ts

@@ -1,312 +0,0 @@
-/**
- * Tests for Memos API Client
- */
-
-import { describe, it, mock, beforeEach } from "node:test";
-import assert from "node:assert";
-import { MemosClient } from "./memos-client.ts";
-
-// Mock fetch function - cast to any since undici's fetch has slightly different types
-const mockFetch = mock.fn<typeof globalThis.fetch>();
-
-describe("MemosClient", () => {
-  let client: MemosClient;
-
-  beforeEach(() => {
-    mockFetch.mock.resetCalls();
-    client = new MemosClient({
-      baseUrl: "https://memos.example.com",
-      accessToken: "test-token",
-      // Inject mock fetch via config instead of globalThis
-      fetch: mockFetch as unknown as typeof import("undici").fetch,
-    });
-  });
-
-  describe("constructor", () => {
-    it("should remove trailing slash from baseUrl", () => {
-      const clientWithSlash = new MemosClient({
-        baseUrl: "https://memos.example.com/",
-        accessToken: "test-token",
-        fetch: mockFetch as unknown as typeof import("undici").fetch,
-      });
-      // We can verify this by checking a request URL
-      mockFetch.mock.mockImplementationOnce(() =>
-        Promise.resolve(new Response(JSON.stringify({ name: "users/1" }), { status: 200 })),
-      );
-
-      clientWithSlash.getCurrentUser();
-
-      const callArgs = mockFetch.mock.calls[0];
-      assert.ok(callArgs);
-      assert.strictEqual(callArgs.arguments[0], "https://memos.example.com/api/v1/auth/me");
-    });
-  });
-
-  describe("createMemo", () => {
-    it("should create a memo with content only", async () => {
-      const mockMemo = {
-        name: "memos/abc123",
-        content: "Test memo",
-        visibility: "PRIVATE",
-        tags: [],
-        createTime: "2024-01-01T00:00:00Z",
-      };
-
-      mockFetch.mock.mockImplementationOnce(() =>
-        Promise.resolve(new Response(JSON.stringify(mockMemo), { status: 200 })),
-      );
-
-      const result = await client.createMemo({ content: "Test memo" });
-
-      assert.strictEqual(result.name, "memos/abc123");
-      assert.strictEqual(result.content, "Test memo");
-
-      const callArgs = mockFetch.mock.calls[0];
-      assert.ok(callArgs);
-      assert.strictEqual(callArgs.arguments[0], "https://memos.example.com/api/v1/memos");
-      assert.strictEqual(callArgs.arguments[1]?.method, "POST");
-      assert.strictEqual(
-        (callArgs.arguments[1]?.headers as Record<string, string>)?.Authorization,
-        "Bearer test-token",
-      );
-    });
-
-    it("should create a memo with visibility and location", async () => {
-      const mockMemo = {
-        name: "memos/xyz789",
-        content: "Geo memo",
-        visibility: "PUBLIC",
-        location: { placeholder: "NYC", latitude: 40.7, longitude: -74.0 },
-      };
-
-      mockFetch.mock.mockImplementationOnce(() =>
-        Promise.resolve(new Response(JSON.stringify(mockMemo), { status: 200 })),
-      );
-
-      const result = await client.createMemo({
-        content: "Geo memo",
-        visibility: "PUBLIC",
-        location: { placeholder: "NYC", latitude: 40.7, longitude: -74.0 },
-      });
-
-      assert.strictEqual(result.visibility, "PUBLIC");
-      assert.deepStrictEqual(result.location, { placeholder: "NYC", latitude: 40.7, longitude: -74.0 });
-
-      const callArgs = mockFetch.mock.calls[0];
-      const body = JSON.parse(callArgs?.arguments[1]?.body as string);
-      assert.strictEqual(body.content, "Geo memo");
-      assert.strictEqual(body.visibility, "PUBLIC");
-      assert.deepStrictEqual(body.location, { placeholder: "NYC", latitude: 40.7, longitude: -74.0 });
-    });
-
-    it("should throw error on API failure", async () => {
-      mockFetch.mock.mockImplementationOnce(() =>
-        Promise.resolve(new Response("Unauthorized", { status: 401, statusText: "Unauthorized" })),
-      );
-
-      await assert.rejects(async () => await client.createMemo({ content: "Test" }), {
-        message: /Memos API error: 401/,
-      });
-    });
-  });
-
-  describe("listMemos", () => {
-    it("should list memos without filters", async () => {
-      const mockResponse = {
-        memos: [{ name: "memos/1", content: "Memo 1" }],
-        nextPageToken: "token123",
-      };
-
-      mockFetch.mock.mockImplementationOnce(() =>
-        Promise.resolve(new Response(JSON.stringify(mockResponse), { status: 200 })),
-      );
-
-      const result = await client.listMemos();
-
-      assert.strictEqual(result.memos.length, 1);
-      assert.strictEqual(result.nextPageToken, "token123");
-
-      const callArgs = mockFetch.mock.calls[0];
-      assert.strictEqual(callArgs?.arguments[0], "https://memos.example.com/api/v1/memos");
-    });
-
-    it("should list memos with all filters", async () => {
-      const mockResponse = { memos: [], nextPageToken: undefined };
-
-      mockFetch.mock.mockImplementationOnce(() =>
-        Promise.resolve(new Response(JSON.stringify(mockResponse), { status: 200 })),
-      );
-
-      await client.listMemos({
-        filter: 'visibility == "PUBLIC"',
-        pageSize: 50,
-        pageToken: "abc",
-        state: "ARCHIVED",
-        orderBy: "create_time desc",
-      });
-
-      const callArgs = mockFetch.mock.calls[0];
-      const url = callArgs?.arguments[0] as string;
-
-      assert.ok(url.includes("filter=visibility"));
-      assert.ok(url.includes("pageSize=50"));
-      assert.ok(url.includes("pageToken=abc"));
-      assert.ok(url.includes("state=ARCHIVED"));
-      assert.ok(url.includes("orderBy=create_time"));
-    });
-  });
-
-  describe("getMemo", () => {
-    it("should get a memo by ID", async () => {
-      const mockMemo = {
-        name: "memos/abc123",
-        content: "My memo",
-        visibility: "PRIVATE",
-      };
-
-      mockFetch.mock.mockImplementationOnce(() =>
-        Promise.resolve(new Response(JSON.stringify(mockMemo), { status: 200 })),
-      );
-
-      const result = await client.getMemo("abc123");
-
-      assert.strictEqual(result.name, "memos/abc123");
-      assert.strictEqual(result.content, "My memo");
-
-      const callArgs = mockFetch.mock.calls[0];
-      assert.strictEqual(callArgs?.arguments[0], "https://memos.example.com/api/v1/memos/abc123");
-    });
-
-    it("should throw error when memo not found", async () => {
-      mockFetch.mock.mockImplementationOnce(() =>
-        Promise.resolve(new Response("Not Found", { status: 404, statusText: "Not Found" })),
-      );
-
-      await assert.rejects(async () => await client.getMemo("nonexistent"), {
-        message: /Memos API error: 404/,
-      });
-    });
-  });
-
-  describe("searchMemos", () => {
-    it("should search memos by query", async () => {
-      const mockResponse = {
-        memos: [{ name: "memos/1", content: "Hello world" }],
-      };
-
-      mockFetch.mock.mockImplementationOnce(() =>
-        Promise.resolve(new Response(JSON.stringify(mockResponse), { status: 200 })),
-      );
-
-      await client.searchMemos("Hello");
-
-      const callArgs = mockFetch.mock.calls[0];
-      const url = callArgs?.arguments[0] as string;
-
-      // URL will be encoded, check for the encoded version
-      assert.ok(url.includes("filter="));
-      assert.ok(decodeURIComponent(url).includes('content.contains("Hello")'));
-    });
-
-    it("should escape quotes in search query", async () => {
-      const mockResponse = { memos: [] };
-
-      mockFetch.mock.mockImplementationOnce(() =>
-        Promise.resolve(new Response(JSON.stringify(mockResponse), { status: 200 })),
-      );
-
-      await client.searchMemos('test "quoted" text');
-
-      const callArgs = mockFetch.mock.calls[0];
-      const url = callArgs?.arguments[0] as string;
-
-      // Check decoded URL contains escaped quotes
-      const decodedUrl = decodeURIComponent(url);
-      assert.ok(decodedUrl.includes('\\"quoted\\"'));
-    });
-
-    it("should pass additional options to listMemos", async () => {
-      const mockResponse = { memos: [] };
-
-      mockFetch.mock.mockImplementationOnce(() =>
-        Promise.resolve(new Response(JSON.stringify(mockResponse), { status: 200 })),
-      );
-
-      await client.searchMemos("test", { pageSize: 10, state: "ARCHIVED" });
-
-      const callArgs = mockFetch.mock.calls[0];
-      const url = callArgs?.arguments[0] as string;
-
-      assert.ok(url.includes("pageSize=10"));
-      assert.ok(url.includes("state=ARCHIVED"));
-    });
-  });
-
-  describe("searchByTag", () => {
-    it("should search memos by tag", async () => {
-      const mockResponse = {
-        memos: [{ name: "memos/1", content: "#important task", tags: ["important"] }],
-      };
-
-      mockFetch.mock.mockImplementationOnce(() =>
-        Promise.resolve(new Response(JSON.stringify(mockResponse), { status: 200 })),
-      );
-
-      await client.searchByTag("important");
-
-      const callArgs = mockFetch.mock.calls[0];
-      const url = callArgs?.arguments[0] as string;
-
-      // Check URL contains filter parameter with tag
-      assert.ok(url.includes("filter="));
-      assert.ok(url.includes("important"));
-    });
-  });
-
-  describe("getCurrentUser", () => {
-    it("should get current user info", async () => {
-      const mockUser = { name: "users/1", username: "testuser" };
-
-      mockFetch.mock.mockImplementationOnce(() =>
-        Promise.resolve(new Response(JSON.stringify(mockUser), { status: 200 })),
-      );
-
-      const result = await client.getCurrentUser();
-
-      assert.deepStrictEqual(result, { name: "users/1", username: "testuser" });
-
-      const callArgs = mockFetch.mock.calls[0];
-      assert.strictEqual(callArgs?.arguments[0], "https://memos.example.com/api/v1/auth/me");
-    });
-  });
-
-  describe("testConnection", () => {
-    it("should return true on successful connection", async () => {
-      mockFetch.mock.mockImplementationOnce(() =>
-        Promise.resolve(new Response(JSON.stringify({ name: "users/1" }), { status: 200 })),
-      );
-
-      const result = await client.testConnection();
-
-      assert.strictEqual(result, true);
-    });
-
-    it("should return false on failed connection", async () => {
-      mockFetch.mock.mockImplementationOnce(() =>
-        Promise.resolve(new Response("Unauthorized", { status: 401, statusText: "Unauthorized" })),
-      );
-
-      const result = await client.testConnection();
-
-      assert.strictEqual(result, false);
-    });
-
-    it("should return false on network error", async () => {
-      mockFetch.mock.mockImplementationOnce(() => Promise.reject(new Error("Network error")));
-
-      const result = await client.testConnection();
-
-      assert.strictEqual(result, false);
-    });
-  });
-});

package/tsconfig.json

@@ -1,25 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "lib": ["ES2022"],
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "noEmit": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "isolatedModules": true,
-    "verbatimModuleSyntax": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-    "noPropertyAccessFromIndexSignature": false,
-    "allowImportingTsExtensions": true
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}