@ainote/mcp 1.0.3 → 1.1.1

package/README.md

@@ -52,17 +52,86 @@ All transports expose the same tool catalog. Choose the option that matches your
 ## Features
 
 - 📝 **Task Management**: Create, update, delete, and list tasks directly from Claude Desktop
+- 📄 **Dev Docs**: Manage CLAUDE.md, Cursor rules, Windsurf rules, and dev documents centrally via MCP
+- 🗂️ **Dev Category Hierarchy**: Auto-organized under `dev/` with subcategories (claude, cursor, windsurf, copilot, docs)
 - 🏷️ **Category Support**: Organize tasks with categories
-- 🔍 **Advanced Search**: Search tasks by content, status, and more
+- 🔍 **Advanced Filtering**: 18+ filter options including date ranges, location, overdue tasks
 - ⭐ **Priority Management**: Mark tasks as important
-- 📅 **Due Date Support**: Set and manage task due dates
-- 🔒 **Secure API Integration**: Uses API key authentication for secure access
+- 📅 **Smart Due Dates**: Human-readable format with relative time (e.g., `'26.1.25 14:30 - 오늘`)
+- 🔒 **Dual Authentication**: Support for both User API Key (24-char) and MCP Key (64-char)
+- 📊 **Usage Tracking**: Automatic API usage statistics per MCP key
+- 🌊 **Streaming API**: Real-time streaming for bulk operations and large datasets
+- 🤖 **Bot Integration**: Telegram bot support via Clawdbot + mcporter
+
+## Quick Start (No Account Needed)
+
+You can start using AI Note MCP **without an existing account**. The MCP server includes onboarding tools that let you sign up and get an API key directly from Claude:
+
+### 1. Add to your MCP config (no API key yet)
+
+```json
+{
+  "mcpServers": {
+    "ainote": {
+      "command": "npx",
+      "args": ["-y", "@ainote/mcp"]
+    }
+  }
+}
+```
+
+### 2. Restart Claude Desktop
+
+### 3. Ask Claude to sign you up
+
+> "Sign me up for AI Note with email user@example.com and password mypassword123"
+
+Claude will call the `signup_and_get_key` tool and return your MCP API key.
+
+### 4. Add the API key to your config
+
+```json
+{
+  "mcpServers": {
+    "ainote": {
+      "command": "npx",
+      "args": ["-y", "@ainote/mcp"],
+      "env": {
+        "AINOTE_API_KEY": "<your-key-from-step-3>"
+      }
+    }
+  }
+}
+```
+
+### 5. Restart Claude Desktop again
+
+Now all tools (tasks, dev docs, etc.) are available.
+
+### CLI Signup
+
+You can also sign up directly from the terminal:
+
+```bash
+npx @ainote/mcp signup
+```
+
+This will interactively ask for email, password, and name, then return your MCP API key.
+
+### Onboarding MCP Tools
+
+These tools also work inside Claude (no API key needed):
+
+| Tool | Description |
+|------|-------------|
+| `signup_and_get_key` | Create account + get MCP key |
+| `login_and_get_key` | Login + get MCP key (existing account) |
+| `get_setup_guide` | Setup instructions |
 
 ## Prerequisites
 
 - Node.js >= 18.0.0
 - npm or yarn
-- AI Note API access (API key required)
 - Claude Desktop with MCP support enabled
 
 ## Installation
@@ -217,6 +286,44 @@ Authorization: Bearer YOUR_API_KEY
 
 This HTTP endpoint provides identical functionality to the stdio version, making AI Note MCP accessible to a broader range of platforms and integration scenarios.
 
+### 4. **Streaming API** - For Large Data Operations
+- **URL**: `POST https://api.ainote.dev/mcp/stream`
+- **Protocol**: Server-Sent Events (SSE)
+- **Usage**: Bulk operations, large task lists, real-time progress
+- **Best for**: Applications that need to handle large datasets or show progress indicators
+
+#### Streaming Methods
+| Method | Description |
+|--------|-------------|
+| `tasks/list` | Stream task list with filters |
+| `tasks/create` | Create single task with progress |
+| `tasks/analyze` | Get task statistics and insights |
+| `tasks/bulk_update` | Update multiple tasks with progress |
+| `tasks/bulk_create` | Create up to 1000 tasks at once |
+
+#### Streaming Events
+```
+event: progress
+data: {"status": "starting", "total": 100}
+
+event: data
+data: {"type": "task", "data": {...}}
+
+event: result
+data: {"status": "success", "count": 100}
+```
+
+### 5. **Telegram Bot Integration** - Via Clawdbot
+- **Setup Guide**: [CLAWDBOT_SETUP.md](./CLAWDBOT_SETUP.md)
+- **Tool**: mcporter for MCP server bridging
+- **Usage**: Natural language task management in Telegram
+
+```bash
+# Quick setup
+npm install -g mcporter
+mcporter call ainote.list_tasks
+```
+
 ### Local Development Bridge (`ainote-mcp-http`)
 
 Run the bundled HTTP/SSE bridge when you need a local endpoint for ChatGPT or other MCP clients that speak SSE:
@@ -248,12 +355,31 @@ When OAuth is enabled the server expects `Authorization: Bearer ...` headers fro
 
 ### list_tasks
 
-List tasks from AI Note with filtering options.
+List tasks from AI Note with advanced filtering options.
 
-**Parameters:**
+**Basic Parameters:**
 - `status` (optional): Filter by status - "pending" or "completed"
 - `limit` (optional): Maximum number of tasks (default: 25, max: 500)
 - `search` (optional): Search keyword in task content
+- `is_important` (optional): Filter important tasks only
+
+**Location & Category:**
+- `location` (optional): Filter by location (partial match, e.g., "여의도")
+- `category_id` (optional): Filter by category UUID
+
+**Date Range Filters:**
+- `due_date_start` / `due_date_end`: Filter by due date range
+- `completed_date_start` / `completed_date_end`: Filter by completion date
+- `created_date_start` / `created_date_end`: Filter by creation date
+
+**Special Filters:**
+- `overdue` (optional): Filter overdue incomplete tasks
+- `due_today` (optional): Filter tasks due today
+- `has_notification` (optional): Filter by notification status
+
+**Sorting:**
+- `sort_by` (optional): Sort field - "due_date", "created_at", "completed_at", "updated_at", "is_important"
+- `sort_order` (optional): Sort direction - "asc" or "desc"
 
 ### create_task
 
@@ -288,6 +414,80 @@ List all available categories.
 
 **Parameters:** None
 
+---
+
+### Dev Doc Tools (v1.1.0+)
+
+Manage AI coding tool configuration files and dev documents centrally. All docs are organized under the `dev/` category hierarchy.
+
+#### list_dev_docs
+
+List dev documents with optional filtering.
+
+**Parameters:**
+- `category` (optional): Subcategory filter (claude, cursor, windsurf, copilot, docs)
+- `search` (optional): Search keyword in document title
+- `content_type` (optional): Filter by type - "markdown", "json", "yaml", "text"
+
+#### get_dev_doc
+
+Get a single dev document by title or id.
+
+**Parameters:**
+- `title` or `id` (one required): Document identifier
+- `category` (optional): Subcategory to disambiguate title
+- `include_versions` (optional): Include version history
+
+#### create_dev_doc
+
+Create a new dev document under `dev/` category.
+
+**Parameters:**
+- `title` (required): Document title (e.g., "project-a-claude.md")
+- `content` (required): Document content
+- `category` (optional): Subcategory (default: "docs")
+- `content_type` (optional): Auto-detected from title extension
+
+#### update_dev_doc
+
+Update a dev document with replace, append, or prepend modes.
+
+**Parameters:**
+- `title` or `id` (one required): Document identifier
+- `content` (required): New content
+- `mode` (optional): "replace" (default), "append", or "prepend"
+
+#### delete_dev_doc
+
+Soft delete a dev document.
+
+**Parameters:**
+- `title` or `id` (one required): Document identifier
+
+#### list_dev_categories
+
+List all subcategories under `dev/` with document counts.
+
+**Parameters:** None
+
+#### Example: Store CLAUDE.md in ainote
+
+```
+You: "Save this project's CLAUDE.md content to ainote"
+Claude: I'll create a dev doc in the claude category...
+→ create_dev_doc(title: "myproject-claude.md", content: "...", category: "claude")
+
+You: "Update my cursor rules in ainote"
+Claude: I'll update the cursor rules doc...
+→ update_dev_doc(title: "api-rules.mdc", category: "cursor", content: "...")
+
+You: "Show me all my dev docs"
+Claude: I'll list all documents under dev/...
+→ list_dev_docs()
+```
+
+---
+
 ## API Reference
 
 The MCP server communicates with the AI Note API using the following endpoints:

package/index.js

@@ -1,25 +1,31 @@
 #!/usr/bin/env node
 /**
  * AI Note MCP Server - Claude Desktop Integration (stdio transport)
+ * Also supports CLI subcommands: signup
  */
 
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { resolveAuthContext } from './lib/auth/strategy-factory.js';
-import { createClaudeServer } from './lib/core/server-factory.js';
+const subcommand = process.argv[2];
 
-const transport = new StdioServerTransport();
+if (subcommand === 'signup') {
+  const { runSignup } = await import('./lib/cli/signup.js');
+  await runSignup();
+} else {
+  // Default: start MCP stdio server
+  const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
+  const { resolveAuthContext } = await import('./lib/auth/strategy-factory.js');
+  const { createClaudeServer } = await import('./lib/core/server-factory.js');
 
-let defaultAuthContext;
+  const transport = new StdioServerTransport();
+  const defaultAuthContext = resolveAuthContext('stdio');
 
-try {
-  defaultAuthContext = resolveAuthContext('stdio');
-} catch (error) {
-  console.error(`[ainote-mcp] Authentication error: ${error.message}`);
-  process.exitCode = 1;
-  throw error;
-}
+  if (defaultAuthContext.type === 'anonymous') {
+    console.error('[ainote-mcp] No AINOTE_API_KEY found. Starting in onboarding mode.');
+    console.error('[ainote-mcp] Use signup_and_get_key or login_and_get_key to get started.');
+    console.error('[ainote-mcp] Or run: npx @ainote/mcp signup');
+  }
 
-const { server } = createClaudeServer({ defaultAuthContext });
+  const { server } = createClaudeServer({ defaultAuthContext });
 
-await server.connect(transport);
-console.error('AI Note MCP stdio server started (Claude Desktop compatible)');
+  await server.connect(transport);
+  console.error('AI Note MCP stdio server started (Claude Desktop compatible)');
+}

package/lib/auth/strategy-factory.js

@@ -4,15 +4,28 @@ import { getFeatureFlags } from '../core/config.js';
 
 export function resolveAuthContext(transportType, headers = {}) {
   if (transportType === 'stdio') {
-    return authenticateWithMcpKey();
+    try {
+      return authenticateWithMcpKey();
+    } catch {
+      // No API key configured — allow anonymous mode for onboarding tools
+      return { type: 'anonymous' };
+    }
   }
 
   const features = getFeatureFlags();
 
   if (transportType === 'sse' && features.oauthAuth) {
-    return authenticateWithOAuth(headers);
+    try {
+      return authenticateWithOAuth(headers);
+    } catch {
+      // Fall through to MCP key or anonymous
+    }
   }
 
-  // Default fallback to MCP key to maintain backward compatibility.
-  return authenticateWithMcpKey();
+  // Default fallback to MCP key, then anonymous for onboarding
+  try {
+    return authenticateWithMcpKey();
+  } catch {
+    return { type: 'anonymous' };
+  }
 }

package/lib/cli/signup.js

@@ -0,0 +1,118 @@
+import * as readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import axios from 'axios';
+import { getConfig } from '../core/config-manager.js';
+
+/**
+ * Interactive CLI signup for AI Note MCP.
+ * Usage: ainote-mcp signup
+ */
+export async function runSignup() {
+  const config = getConfig();
+  const rl = readline.createInterface({ input, output });
+
+  console.log('\n  AI Note MCP — Sign Up\n');
+
+  try {
+    const email = await rl.question('  Email: ');
+    const password = await rl.question('  Password (min 6 chars): ');
+    const name = await rl.question('  Name (optional, press Enter to skip): ');
+
+    if (!email.trim() || !password.trim()) {
+      console.error('\n  Error: Email and password are required.\n');
+      process.exit(1);
+    }
+
+    if (password.trim().length < 6) {
+      console.error('\n  Error: Password must be at least 6 characters.\n');
+      process.exit(1);
+    }
+
+    console.log('\n  Creating account...');
+
+    const rpcRequest = {
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'tools/call',
+      params: {
+        name: 'signup_and_get_key',
+        arguments: {
+          email: email.trim(),
+          password: password.trim(),
+          ...(name.trim() ? { name: name.trim() } : {})
+        }
+      }
+    };
+
+    const response = await axios.post(`${config.api.url}/api/mcp`, rpcRequest, {
+      headers: { 'Content-Type': 'application/json' },
+      timeout: 30000
+    });
+
+    const data = response.data?.data;
+
+    // Check for JSON-RPC error
+    if (data?.error) {
+      console.error(`\n  Error: ${data.error.message}`);
+      if (data.error.data?.suggestion) {
+        console.log(`  Hint: ${data.error.data.suggestion}`);
+      }
+      console.log();
+      process.exit(1);
+    }
+
+    // Extract MCP key from structured resource data
+    const content = data?.result?.content;
+    let mcpKey = null;
+
+    if (Array.isArray(content)) {
+      for (const item of content) {
+        if (item.type === 'resource' && item.resource?.text) {
+          try {
+            const resourceData = JSON.parse(item.resource.text);
+            mcpKey = resourceData.mcp_key;
+          } catch { /* ignore */ }
+        }
+      }
+    }
+
+    if (mcpKey) {
+      console.log('\n  Account created successfully!\n');
+      console.log(`  Your MCP API Key:\n`);
+      console.log(`    ${mcpKey}\n`);
+      console.log('  Add this to your MCP config:\n');
+      console.log('  {');
+      console.log('    "mcpServers": {');
+      console.log('      "ainote": {');
+      console.log('        "command": "npx",');
+      console.log('        "args": ["-y", "@ainote/mcp"],');
+      console.log('        "env": {');
+      console.log(`          "AINOTE_API_KEY": "${mcpKey}"`);
+      console.log('        }');
+      console.log('      }');
+      console.log('    }');
+      console.log('  }\n');
+      console.log('  Then restart Claude Desktop.\n');
+    } else {
+      // Fallback: print text content
+      if (Array.isArray(content)) {
+        for (const item of content) {
+          if (item.type === 'text') {
+            console.log(`\n${item.text}\n`);
+          }
+        }
+      } else {
+        console.log('\n  Account created! Check the response for your API key.\n');
+      }
+    }
+  } catch (error) {
+    if (error.response?.data) {
+      console.error(`\n  Error: ${JSON.stringify(error.response.data)}\n`);
+    } else {
+      console.error(`\n  Error: ${error.message}\n`);
+    }
+    process.exit(1);
+  } finally {
+    rl.close();
+  }
+}

package/lib/core/server-factory.js

@@ -5,6 +5,8 @@ import { getConfig } from './config-manager.js';
 import { createApiClient } from '../utils/api-client.js';
 import { getSharedTools } from '../tools/shared-tools.js';
 import { getChatGptTools } from '../tools/chatgpt-tools.js';
+import { getDevDocTools } from '../tools/dev-doc-tools.js';
+import { getOnboardingTools } from '../tools/onboarding-tools.js';
 import { toErrorContent } from '../tools/internal/formatters.js';
 
 function buildServerInfo(profile) {
@@ -15,7 +17,10 @@ function buildServerInfo(profile) {
 }
 
 function registerTools(registry, { includeChatGpt }) {
+  // Onboarding tools are always registered (work without API key)
+  registry.registerMany(getOnboardingTools());
   registry.registerMany(getSharedTools());
+  registry.registerMany(getDevDocTools());
 
   if (includeChatGpt) {
     registry.registerMany(getChatGptTools());

package/lib/tools/dev-doc-tools.js

@@ -0,0 +1,255 @@
+import { toSuccessContent } from './internal/formatters.js';
+import fs from 'fs';
+import path from 'path';
+
+function listDevDocsDefinition() {
+  return {
+    name: 'list_dev_docs',
+    description: `List your synced dev documents stored in AI Note cloud.
+
+Shows all documents under dev/ category including memory files, AI configs, and project docs.
+Use this to see what's synced and which files have local_path set for multi-device sync.
+
+Categories: memory, claude, cursor, windsurf, env, docs, or custom subcategories.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        category: {
+          type: 'string',
+          description: 'Subcategory filter (claude, cursor, windsurf, copilot, docs, etc.)'
+        },
+        search: {
+          type: 'string',
+          description: 'Search keyword in document title'
+        },
+        content_type: {
+          type: 'string',
+          enum: ['markdown', 'json', 'yaml', 'text'],
+          description: 'Filter by content type'
+        }
+      }
+    }
+  };
+}
+
+function getDevDocDefinition() {
+  return {
+    name: 'get_dev_doc',
+    description: 'Get a single dev document by title or id. Returns full content.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Document title (e.g., project-a-memory.md)' },
+        id: { type: 'string', description: 'Document UUID' },
+        category: { type: 'string', description: 'Subcategory (claude, cursor, etc.) to disambiguate' },
+        include_versions: { type: 'boolean', description: 'Include version history (default: false)' }
+      }
+    }
+  };
+}
+
+function createDevDocDefinition() {
+  return {
+    name: 'create_dev_doc',
+    description: `Save a file to AI Note cloud for multi-device sync.
+
+PRIMARY USE CASES:
+- Memory files: ~/.claude/projects/.../memory/MEMORY.md
+- AI configs: CLAUDE.md, .cursorrules, .windsurfrules (not in git)
+- Project docs: architecture notes, planning docs
+
+Set local_path to enable pull_dev_docs auto-sync on other devices.
+Categories: memory | claude | cursor | env | docs`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Document title (e.g., project-a-claude.md)' },
+        content: { type: 'string', description: 'Document content (markdown, json, yaml)' },
+        category: {
+          type: 'string',
+          description: 'Subcategory (claude, cursor, windsurf, copilot, docs). Default: docs'
+        },
+        content_type: {
+          type: 'string',
+          enum: ['markdown', 'json', 'yaml', 'text'],
+          description: 'Content type. Auto-detected from title extension if omitted.'
+        },
+        local_path: {
+          type: 'string',
+          description: 'Absolute local file path for multi-device sync (e.g., ~/.claude/projects/.../MEMORY.md)'
+        }
+      },
+      required: ['title', 'content']
+    }
+  };
+}
+
+function updateDevDocDefinition() {
+  return {
+    name: 'update_dev_doc',
+    description: 'Update a dev document. Supports replace, append, or prepend modes.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Document title' },
+        id: { type: 'string', description: 'Document UUID' },
+        category: { type: 'string', description: 'Subcategory to disambiguate' },
+        content: { type: 'string', description: 'New content' },
+        mode: {
+          type: 'string',
+          enum: ['replace', 'append', 'prepend'],
+          description: 'Update mode (default: replace)'
+        },
+        local_path: {
+          type: 'string',
+          description: 'Update the local file path for multi-device sync'
+        }
+      },
+      required: ['content']
+    }
+  };
+}
+
+function deleteDevDocDefinition() {
+  return {
+    name: 'delete_dev_doc',
+    description: 'Delete a dev document (soft delete).',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        title: { type: 'string', description: 'Document title' },
+        id: { type: 'string', description: 'Document UUID' },
+        category: { type: 'string', description: 'Subcategory to disambiguate' }
+      }
+    }
+  };
+}
+
+function pullDevDocsDefinition() {
+  return {
+    name: 'pull_dev_docs',
+    description: `Restore all synced files to THIS device. Writes files to their local paths on disk.
+
+USE THIS WHEN:
+- Setting up a new machine (desktop, laptop)
+- Reinstalled macOS / fresh environment
+- Want to sync latest versions of memory/config files from cloud
+
+WHAT HAPPENS:
+1. Fetches all dev docs with local_path set
+2. Creates missing parent directories
+3. Writes content to each local_path on this machine
+
+Run once after installing ainote MCP on a new device to restore everything.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        category: {
+          type: 'string',
+          description: 'Subcategory filter. Omit to pull all docs with local_path.'
+        }
+      }
+    }
+  };
+}
+
+function listDevCategoriesDefinition() {
+  return {
+    name: 'list_dev_categories',
+    description: 'List all subcategories under dev/. Shows document count per category.',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
+  };
+}
+
+export function getDevDocTools() {
+  return [
+    {
+      definition: listDevDocsDefinition(),
+      handler: async (args, { apiClient }) => {
+        const result = await apiClient.callTool('list_dev_docs', args);
+        return result;
+      }
+    },
+    {
+      definition: getDevDocDefinition(),
+      handler: async (args, { apiClient }) => {
+        const result = await apiClient.callTool('get_dev_doc', args);
+        return result;
+      }
+    },
+    {
+      definition: createDevDocDefinition(),
+      handler: async (args, { apiClient }) => {
+        const result = await apiClient.callTool('create_dev_doc', args);
+        return result;
+      }
+    },
+    {
+      definition: updateDevDocDefinition(),
+      handler: async (args, { apiClient }) => {
+        const result = await apiClient.callTool('update_dev_doc', args);
+        return result;
+      }
+    },
+    {
+      definition: deleteDevDocDefinition(),
+      handler: async (args, { apiClient }) => {
+        const result = await apiClient.callTool('delete_dev_doc', args);
+        return result;
+      }
+    },
+    {
+      definition: pullDevDocsDefinition(),
+      handler: async (args, { apiClient }) => {
+        const result = await apiClient.callTool('pull_dev_docs', args);
+
+        // Extract docs from resource data and write to local paths
+        let written = [];
+        let skipped = [];
+        let errors = [];
+
+        try {
+          const resourceText = result?.content?.find(c => c.type === 'resource')?.resource?.text;
+          if (resourceText) {
+            const data = JSON.parse(resourceText);
+            for (const doc of data.docs || []) {
+              if (!doc.local_path || !doc.content) {
+                skipped.push(doc.title);
+                continue;
+              }
+              const expandedPath = doc.local_path.replace(/^~/, process.env.HOME || '');
+              try {
+                const dir = path.dirname(expandedPath);
+                fs.mkdirSync(dir, { recursive: true });
+                fs.writeFileSync(expandedPath, doc.content, 'utf8');
+                written.push(`✅ ${doc.title} → ${expandedPath}`);
+              } catch (e) {
+                errors.push(`❌ ${doc.title}: ${e.message}`);
+              }
+            }
+          }
+        } catch (e) {
+          errors.push(`Parse error: ${e.message}`);
+        }
+
+        const summary = [
+          written.length ? `Written (${written.length}):\n${written.join('\n')}` : null,
+          skipped.length ? `Skipped (no local_path): ${skipped.join(', ')}` : null,
+          errors.length ? `Errors:\n${errors.join('\n')}` : null,
+        ].filter(Boolean).join('\n\n');
+
+        return [{ type: 'text', text: summary || 'No docs with local_path found.' }];
+      }
+    },
+    {
+      definition: listDevCategoriesDefinition(),
+      handler: async (_args, { apiClient }) => {
+        const result = await apiClient.callTool('list_dev_categories', {});
+        return result;
+      }
+    }
+  ];
+}

package/lib/tools/index.js

@@ -1,3 +1,5 @@
 export { getSharedTools } from './shared-tools.js';
 export { getChatGptTools } from './chatgpt-tools.js';
+export { getDevDocTools } from './dev-doc-tools.js';
+export { getOnboardingTools } from './onboarding-tools.js';
 export { toSuccessContent, toErrorContent } from './internal/formatters.js';

package/lib/tools/internal/formatters.js

@@ -35,3 +35,46 @@ export function toErrorContent(error) {
     isError: true
   };
 }
+
+/**
+ * Parse structured data from MCP response
+ * Looks for JSON resource in content array and extracts structured data
+ */
+export function parseStructuredData(result) {
+  if (!result?.content || !Array.isArray(result.content)) {
+    return null;
+  }
+
+  // Look for resource content with JSON data
+  for (const item of result.content) {
+    if (item.type === 'resource' && item.resource?.mimeType === 'application/json') {
+      try {
+        return JSON.parse(item.resource.text);
+      } catch (error) {
+        console.error('Failed to parse structured data:', error);
+        return null;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Enhance result with structured data annotation
+ * Adds structured data to the response while preserving original text
+ */
+export function enhanceWithStructuredData(result) {
+  const structuredData = parseStructuredData(result);
+
+  if (structuredData) {
+    // Add metadata about structured data availability
+    return {
+      ...result,
+      _structuredData: structuredData,
+      _hasStructuredData: true
+    };
+  }
+
+  return result;
+}

package/lib/tools/onboarding-tools.js

@@ -0,0 +1,124 @@
+import axios from 'axios';
+import { getConfig } from '../core/config-manager.js';
+import { toErrorContent } from './internal/formatters.js';
+
+/**
+ * Onboarding tools for signup/login without API key.
+ * These tools call the Rails API directly (no auth headers).
+ */
+
+function signupDefinition() {
+  return {
+    name: 'signup_and_get_key',
+    description: `Create a new AI Note account and get an MCP API key. No authentication required.
+Use this if you don't have an account yet. After getting the key, add it to your MCP config and restart.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        email: { type: 'string', description: 'Email address for the new account' },
+        password: { type: 'string', description: 'Password (minimum 6 characters)' },
+        name: { type: 'string', description: 'Display name (optional)' }
+      },
+      required: ['email', 'password']
+    }
+  };
+}
+
+function loginDefinition() {
+  return {
+    name: 'login_and_get_key',
+    description: `Log in to an existing AI Note account and get an MCP API key. No authentication required.
+Use this if you already have an account but need your MCP key.`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        email: { type: 'string', description: 'Your account email address' },
+        password: { type: 'string', description: 'Your account password' }
+      },
+      required: ['email', 'password']
+    }
+  };
+}
+
+function setupGuideDefinition() {
+  return {
+    name: 'get_setup_guide',
+    description: 'Get instructions for setting up AI Note MCP in Claude Desktop, Cursor, or other MCP clients. Includes CLI signup method (npx @ainote/mcp signup). No authentication required.',
+    inputSchema: {
+      type: 'object',
+      properties: {}
+    }
+  };
+}
+
+/**
+ * Call Rails MCP API directly without auth headers (for onboarding tools).
+ */
+async function callOnboardingTool(toolName, args = {}) {
+  const config = getConfig();
+  const rpcRequest = {
+    jsonrpc: '2.0',
+    id: Date.now(),
+    method: 'tools/call',
+    params: { name: toolName, arguments: args }
+  };
+
+  const response = await axios.post(`${config.api.url}/api/mcp`, rpcRequest, {
+    headers: { 'Content-Type': 'application/json' },
+    timeout: 30000
+  });
+
+  if (response.data?.data?.error) {
+    const err = response.data.data.error;
+    throw new Error(err.message || 'Onboarding tool call failed');
+  }
+
+  // Rails wraps in { success: true, data: { jsonrpc, id, result } }
+  const rpcResult = response.data?.data?.result;
+  if (rpcResult) {
+    return rpcResult;
+  }
+
+  // Fallback: return the raw response content
+  return {
+    content: [{
+      type: 'text',
+      text: JSON.stringify(response.data, null, 2)
+    }]
+  };
+}
+
+export function getOnboardingTools() {
+  return [
+    {
+      definition: signupDefinition(),
+      handler: async (args) => {
+        try {
+          return await callOnboardingTool('signup_and_get_key', args);
+        } catch (error) {
+          return toErrorContent(error);
+        }
+      }
+    },
+    {
+      definition: loginDefinition(),
+      handler: async (args) => {
+        try {
+          return await callOnboardingTool('login_and_get_key', args);
+        } catch (error) {
+          return toErrorContent(error);
+        }
+      }
+    },
+    {
+      definition: setupGuideDefinition(),
+      handler: async () => {
+        try {
+          return await callOnboardingTool('get_setup_guide');
+        } catch (error) {
+          return toErrorContent(error);
+        }
+      }
+    }
+  ];
+}

package/lib/tools/shared-tools.js

@@ -1,9 +1,40 @@
-import { toSuccessContent } from './internal/formatters.js';
+import { toSuccessContent, enhanceWithStructuredData } from './internal/formatters.js';
 
 function listTasksDefinition() {
   return {
     name: 'list_tasks',
-    description: 'List tasks from AI Note',
+    description: `List tasks from AI Note with natural language support and advanced filtering.
+
+NATURAL LANGUAGE EXAMPLES:
+• Location: "여의도에서", "서울에 있는", "강남 관련"
+• Time: "오늘", "이번 주", "다음 주", "지난달", "1월에"
+• Importance: "중요한", "우선순위 높은", "급한"
+• Status: "완료한", "미완료", "안 끝난"
+• Special: "마감일 지난", "늦어진", "오늘 마감", "알림 설정된"
+• Sort: "마감일 순으로", "최신순으로", "오래된 순으로"
+
+QUERY EXAMPLES:
+1. "여의도에서 이번 주 마감인 중요한 미완료 할일"
+   → {location: "여의도", due_date_start: "2025-01-27", due_date_end: "2025-02-02",
+       is_important: true, status: "pending"}
+
+2. "지난달 완료한 업무 카테고리 할일들을 완료일 순으로"
+   → {category_id: "...", status: "completed",
+       completed_date_start: "2024-12-01", completed_date_end: "2024-12-31",
+       sort_by: "completed_at", sort_order: "asc"}
+
+3. "마감일 지났는데 아직 안 끝난 할일들 마감일 빠른 순으로"
+   → {overdue: true, sort_by: "due_date", sort_order: "asc"}
+
+TIME CALCULATIONS (today = 2025-01-27):
+• "오늘" → due_today: true
+• "이번 주" → due_date_start: "2025-01-27", due_date_end: "2025-02-02"
+• "다음 주" → due_date_start: "2025-02-03", due_date_end: "2025-02-09"
+• "이번 달" → due_date_start: "2025-01-01", due_date_end: "2025-01-31"
+• "지난 주" → completed_date_start: "2025-01-20", completed_date_end: "2025-01-26"
+• "지난 달" → completed_date_start: "2024-12-01", completed_date_end: "2024-12-31"
+
+Returns structured data with all task fields including location, dates, and categories.`,
     inputSchema: {
       type: 'object',
       properties: {
@@ -12,6 +43,10 @@ function listTasksDefinition() {
           enum: ['pending', 'completed'],
           description: 'Filter by task status'
         },
+        is_important: {
+          type: 'boolean',
+          description: 'Filter by important tasks only'
+        },
         limit: {
           type: 'number',
           description: 'Maximum number of tasks to return (default: 25, max: 500)'
@@ -19,6 +54,60 @@ function listTasksDefinition() {
         search: {
           type: 'string',
           description: 'Search keyword in task content'
+        },
+        location: {
+          type: 'string',
+          description: 'Filter by location (partial match, e.g., "여의도", "서울")'
+        },
+        category_id: {
+          type: 'string',
+          description: 'Filter by category UUID'
+        },
+        due_date_start: {
+          type: 'string',
+          description: 'Filter tasks with due_date >= this date (ISO 8601 format)'
+        },
+        due_date_end: {
+          type: 'string',
+          description: 'Filter tasks with due_date <= this date (ISO 8601 format)'
+        },
+        completed_date_start: {
+          type: 'string',
+          description: 'Filter tasks completed >= this date (ISO 8601 format)'
+        },
+        completed_date_end: {
+          type: 'string',
+          description: 'Filter tasks completed <= this date (ISO 8601 format)'
+        },
+        created_date_start: {
+          type: 'string',
+          description: 'Filter tasks created >= this date (ISO 8601 format)'
+        },
+        created_date_end: {
+          type: 'string',
+          description: 'Filter tasks created <= this date (ISO 8601 format)'
+        },
+        overdue: {
+          type: 'boolean',
+          description: 'Filter overdue incomplete tasks (due_date < today)'
+        },
+        due_today: {
+          type: 'boolean',
+          description: 'Filter tasks due today'
+        },
+        has_notification: {
+          type: 'boolean',
+          description: 'Filter by notification enabled status'
+        },
+        sort_by: {
+          type: 'string',
+          enum: ['due_date', 'created_at', 'completed_at', 'updated_at', 'is_important'],
+          description: 'Sort field (default: created_at)'
+        },
+        sort_order: {
+          type: 'string',
+          enum: ['asc', 'desc'],
+          description: 'Sort order (default: desc)'
         }
       }
     }
@@ -28,7 +117,7 @@ function listTasksDefinition() {
 function createTaskDefinition() {
   return {
     name: 'create_task',
-    description: 'Create a new task in AI Note',
+    description: 'Create a new task in AI Note with optional notification',
     inputSchema: {
       type: 'object',
       properties: {
@@ -47,6 +136,10 @@ function createTaskDefinition() {
         category_id: {
           type: 'string',
           description: 'Category ID'
+        },
+        notification_minutes_before: {
+          type: 'number',
+          description: 'Set notification X minutes before due_date (e.g., 5 for 5 minutes before, 60 for 1 hour before). Requires due_date to be set.'
         }
       },
       required: ['content']
@@ -117,7 +210,8 @@ export function getSharedTools() {
       definition: listTasksDefinition(),
       handler: async (args, { apiClient }) => {
         const result = await apiClient.callTool('list_tasks', args);
-        return result;  // Return full result with { content: [...] }
+        // Enhance result with parsed structured data
+        return enhanceWithStructuredData(result);
       }
     },
     {

package/lib/utils/api-client.js

@@ -8,6 +8,11 @@ function buildHeaders(authContext, config) {
 
   const contextType = authContext?.type ?? 'mcpKey';
 
+  if (contextType === 'anonymous') {
+    // No auth headers for anonymous mode (onboarding tools)
+    return headers;
+  }
+
   if (contextType === 'oauth') {
     const bearerToken = authContext?.token;
     if (!bearerToken) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ainote/mcp",
-  "version": "1.0.3",
-  "description": "MCP server for AI Note - Connect Claude Desktop to your AI Note tasks",
+  "version": "1.1.1",
+  "description": "MCP server for AI Note - Tasks, Dev Docs, and multi-device file sync (CLAUDE.md, memory files, Cursor rules, Windsurf rules)",
   "main": "index.js",
   "type": "module",
   "bin": {
@@ -21,9 +21,16 @@
     "modelcontextprotocol",
     "model-context-protocol",
     "claude",
+    "claude-code",
     "claude-desktop",
+    "cursor",
+    "windsurf",
+    "copilot",
     "ainote",
     "ai-note",
+    "dev-docs",
+    "claude-md",
+    "memory",
     "tasks",
     "task-management",
     "todo",

package/server.js

@@ -80,12 +80,8 @@ app.post(config.http.messageEndpoint, async (req, res) => {
     return res.status(404).json({ error: `No transport found for sessionId ${sessionId}` });
   }
 
-  try {
-    const authContext = resolveAuthContext('sse', req.headers);
-    req.auth = authContext;
-  } catch (error) {
-    return res.status(401).json({ error: error.message });
-  }
+  const authContext = resolveAuthContext('sse', req.headers);
+  req.auth = authContext;
 
   try {
     await session.transport.handlePostMessage(req, res, req.body);