@starascendin/lifeos-mcp 0.1.0

package/README.md

@@ -0,0 +1,129 @@
+# LifeOS MCP Server
+
+MCP (Model Context Protocol) server for LifeOS Project Management. This allows AI assistants like Claude to interact with your LifeOS projects, tasks, cycles, notes, and contacts.
+
+## Installation
+
+```bash
+npm install -g @starascendin/lifeos-mcp
+```
+
+Or use directly with npx (no install needed):
+
+```bash
+npx @starascendin/lifeos-mcp --url <your-convex-url> --user-id <your-user-id> --api-key <your-api-key>
+```
+
+## Configuration
+
+### Required Parameters
+
+| Parameter | CLI Flag | Env Variable | Description |
+|-----------|----------|--------------|-------------|
+| Convex URL | `--url`, `-u` | `CONVEX_URL` | Your Convex deployment URL (e.g., `https://your-app.convex.site`) |
+| User ID | `--user-id`, `-i` | `LIFEOS_USER_ID` | Your LifeOS user ID |
+| API Key | `--api-key`, `-k` | `LIFEOS_API_KEY` | Your API key for authentication |
+
+### Getting Your Credentials
+
+1. **Convex URL**: Find in your Convex dashboard - use the `.convex.site` URL (not `.convex.cloud`)
+2. **User ID**: In LifeOS app, go to Settings > Developer, or query from Convex Dashboard
+3. **API Key**: Generate from your LifeOS settings or Convex dashboard
+
+## Usage with Claude Code
+
+Add to your `.mcp.json` (project root or `~/.claude/mcp.json`):
+
+### Using CLI flags:
+
+```json
+{
+  "mcpServers": {
+    "lifeos": {
+      "command": "npx",
+      "args": [
+        "@starascendin/lifeos-mcp",
+        "--url", "https://your-app.convex.site",
+        "--user-id", "your-user-id",
+        "--api-key", "your-api-key"
+      ]
+    }
+  }
+}
+```
+
+### Using environment variables:
+
+```json
+{
+  "mcpServers": {
+    "lifeos": {
+      "command": "npx",
+      "args": ["@starascendin/lifeos-mcp"],
+      "env": {
+        "CONVEX_URL": "https://your-app.convex.site",
+        "LIFEOS_USER_ID": "your-user-id",
+        "LIFEOS_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+### Project Management
+- **get_projects** - List all projects with stats
+- **get_tasks** - Get tasks with filters (project, status, priority)
+- **get_todays_tasks** - Get today's tasks and top priorities
+- **create_issue** - Create a new task/issue
+- **mark_issue_complete** - Mark a task as done
+
+### Phases
+- **get_phases** - Get all phases for a project
+- **get_phase** - Get phase details with issues
+- **create_phase** - Create a new phase
+- **update_phase** - Update phase details
+- **delete_phase** - Delete a phase
+- **assign_issue_to_phase** - Assign/unassign issue to phase
+
+### Cycles/Sprints
+- **get_current_cycle** - Get active cycle with progress
+- **assign_issue_to_cycle** - Add task to a cycle
+
+### Agenda
+- **get_daily_agenda** - Today's tasks, events, priorities
+- **get_weekly_agenda** - Week's tasks and events
+
+### Notes
+- **search_notes** - Search voice memos/notes
+- **get_recent_notes** - Get recent notes
+- **create_quick_note** - Create a text note
+- **add_tags_to_note** - Tag a note
+
+### People/Contacts
+- **get_people** - List all contacts
+- **get_person** - Get person details with AI profile
+- **search_people** - Search contacts by name
+- **create_person** - Create a new contact
+- **update_person** - Update contact details
+- **get_memos_for_person** - Get voice memos linked to a person
+- **get_person_timeline** - Get interaction timeline
+- **link_memo_to_person** - Link a memo to a person
+
+### Clients
+- **get_clients** - List all clients
+- **get_client** - Get client details
+- **get_projects_for_client** - Get client's projects
+- **create_client** - Create a new client
+- **update_client** - Update client details
+
+## CLI Help
+
+```bash
+lifeos-mcp --help
+```
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * LifeOS MCP Server
+ *
+ * Exposes LifeOS Project Management tools via Model Context Protocol.
+ * Calls the Convex HTTP /tool-call endpoint.
+ *
+ * CLI flags (take precedence over env vars):
+ *   --url, -u       Convex deployment URL (e.g., https://your-deployment.convex.site)
+ *   --user-id, -i   User ID for API authentication
+ *   --api-key, -k   API key for authentication
+ *
+ * Environment variables (fallback):
+ *   CONVEX_URL      Convex deployment URL
+ *   LIFEOS_USER_ID  User ID for API key auth
+ *   LIFEOS_API_KEY  API key for authentication
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,767 @@
+#!/usr/bin/env node
+/**
+ * LifeOS MCP Server
+ *
+ * Exposes LifeOS Project Management tools via Model Context Protocol.
+ * Calls the Convex HTTP /tool-call endpoint.
+ *
+ * CLI flags (take precedence over env vars):
+ *   --url, -u       Convex deployment URL (e.g., https://your-deployment.convex.site)
+ *   --user-id, -i   User ID for API authentication
+ *   --api-key, -k   API key for authentication
+ *
+ * Environment variables (fallback):
+ *   CONVEX_URL      Convex deployment URL
+ *   LIFEOS_USER_ID  User ID for API key auth
+ *   LIFEOS_API_KEY  API key for authentication
+ */
+import { Command } from "commander";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+// Parse CLI arguments
+const program = new Command();
+program
+    .name("lifeos-mcp")
+    .description("MCP server for LifeOS Project Management")
+    .version("0.1.0")
+    .option("-u, --url <url>", "Convex deployment URL")
+    .option("-i, --user-id <id>", "User ID for API authentication")
+    .option("-k, --api-key <key>", "API key for authentication")
+    .parse();
+const options = program.opts();
+// Tool definitions matching the Convex tool-call endpoint
+const TOOLS = [
+    // Project Management Tools
+    {
+        name: "get_projects",
+        description: "Get user's projects with issue counts and completion stats. Use this to see all projects and their status.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                status: {
+                    type: "string",
+                    enum: ["planned", "in_progress", "paused", "completed", "cancelled"],
+                    description: "Filter by project status",
+                },
+                includeArchived: {
+                    type: "boolean",
+                    description: "Include archived projects (default: false)",
+                },
+            },
+        },
+    },
+    {
+        name: "get_tasks",
+        description: "Get tasks/issues with optional filters. Use this to list tasks in a project or by status/priority.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                projectId: {
+                    type: "string",
+                    description: "Filter by project ID",
+                },
+                status: {
+                    type: "string",
+                    enum: [
+                        "backlog",
+                        "todo",
+                        "in_progress",
+                        "in_review",
+                        "done",
+                        "cancelled",
+                    ],
+                    description: "Filter by task status",
+                },
+                priority: {
+                    type: "string",
+                    enum: ["urgent", "high", "medium", "low", "none"],
+                    description: "Filter by priority level",
+                },
+                limit: {
+                    type: "number",
+                    description: "Max results (default 50, max 100)",
+                },
+            },
+        },
+    },
+    {
+        name: "get_todays_tasks",
+        description: "Get today's tasks including tasks due today and top priority items. Best for daily planning.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "create_issue",
+        description: "Create a new task/issue. Optionally assign to a project, set priority, and due date.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                title: {
+                    type: "string",
+                    description: "The task title (required)",
+                },
+                description: {
+                    type: "string",
+                    description: "Detailed description (optional)",
+                },
+                projectIdOrKey: {
+                    type: "string",
+                    description: "Project ID or key like 'ACME' (optional)",
+                },
+                priority: {
+                    type: "string",
+                    enum: ["urgent", "high", "medium", "low", "none"],
+                    description: "Priority level (optional, default: none)",
+                },
+                dueDate: {
+                    type: "string",
+                    description: "Due date in ISO format like '2024-01-15' (optional)",
+                },
+                cycleId: {
+                    type: "string",
+                    description: "Assign to a specific cycle (optional)",
+                },
+                phaseId: {
+                    type: "string",
+                    description: "Assign to a specific phase within the project (optional)",
+                },
+            },
+            required: ["title"],
+        },
+    },
+    {
+        name: "mark_issue_complete",
+        description: "Mark a task as complete. Accepts issue ID or identifier like 'PROJ-123'.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                issueIdOrIdentifier: {
+                    type: "string",
+                    description: "Issue ID or identifier like PROJ-123 (required)",
+                },
+            },
+            required: ["issueIdOrIdentifier"],
+        },
+    },
+    // Cycle/Sprint Tools
+    {
+        name: "get_current_cycle",
+        description: "Get the currently active cycle/sprint with progress stats and top priority issues.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "assign_issue_to_cycle",
+        description: "Assign a task to a cycle. Defaults to current active cycle if no cycleId provided.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                issueIdOrIdentifier: {
+                    type: "string",
+                    description: "Issue ID or identifier like PROJ-123 (required)",
+                },
+                cycleId: {
+                    type: "string",
+                    description: "Cycle ID (optional, defaults to active cycle)",
+                },
+            },
+            required: ["issueIdOrIdentifier"],
+        },
+    },
+    // Agenda Tools
+    {
+        name: "get_daily_agenda",
+        description: "Get today's full agenda: tasks due today, calendar events, and top priorities.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                date: {
+                    type: "string",
+                    description: "Specific date in ISO format (optional, default: today)",
+                },
+            },
+        },
+    },
+    {
+        name: "get_weekly_agenda",
+        description: "Get weekly agenda: tasks and events for the next 7 days, plus AI weekly summary.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                startDate: {
+                    type: "string",
+                    description: "Start date in ISO format (optional, default: today)",
+                },
+            },
+        },
+    },
+    // Notes Tools
+    {
+        name: "search_notes",
+        description: "Search voice memos/notes by content.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search terms to find in notes (required)",
+                },
+                limit: {
+                    type: "number",
+                    description: "Max results (default 10, max 50)",
+                },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "get_recent_notes",
+        description: "Get recent voice memos/notes with transcripts.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: {
+                    type: "number",
+                    description: "Number of notes to return (default 5, max 20)",
+                },
+            },
+        },
+    },
+    {
+        name: "create_quick_note",
+        description: "Create a quick text note. Useful for capturing thoughts.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                content: {
+                    type: "string",
+                    description: "The note content (required)",
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Tags for categorization (optional)",
+                },
+            },
+            required: ["content"],
+        },
+    },
+    {
+        name: "add_tags_to_note",
+        description: "Add tags to an existing note.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                noteId: {
+                    type: "string",
+                    description: "The note ID (required)",
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Tags to add (required)",
+                },
+            },
+            required: ["noteId", "tags"],
+        },
+    },
+    // FRM (Friend Relationship Management) Tools
+    {
+        name: "get_people",
+        description: "Get all contacts/people with optional filters. Use this to list all your contacts.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                relationshipType: {
+                    type: "string",
+                    enum: ["family", "friend", "colleague", "acquaintance", "mentor", "other"],
+                    description: "Filter by relationship type",
+                },
+                includeArchived: {
+                    type: "boolean",
+                    description: "Include archived people (default: false)",
+                },
+                limit: {
+                    type: "number",
+                    description: "Max results (default 100)",
+                },
+            },
+        },
+    },
+    {
+        name: "get_person",
+        description: "Get a single person's details with their AI-generated profile including communication style, personality insights, and relationship tips.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                personId: {
+                    type: "string",
+                    description: "The person's ID (required)",
+                },
+            },
+            required: ["personId"],
+        },
+    },
+    {
+        name: "search_people",
+        description: "Search contacts by name using full-text search.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search terms to find in names (required)",
+                },
+                limit: {
+                    type: "number",
+                    description: "Max results (default 20)",
+                },
+            },
+            required: ["query"],
+        },
+    },
+    {
+        name: "get_memos_for_person",
+        description: "Get all voice memos linked to a specific person. Shows the transcripts and context for each memo.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                personId: {
+                    type: "string",
+                    description: "The person's ID (required)",
+                },
+                limit: {
+                    type: "number",
+                    description: "Max results (default 50)",
+                },
+            },
+            required: ["personId"],
+        },
+    },
+    {
+        name: "get_person_timeline",
+        description: "Get interaction timeline for a person or all people. Shows voice memos and notes chronologically.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                personId: {
+                    type: "string",
+                    description: "Filter to specific person (omit for all)",
+                },
+                limit: {
+                    type: "number",
+                    description: "Max results (default 50)",
+                },
+            },
+        },
+    },
+    {
+        name: "create_person",
+        description: "Create a new contact/person.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "The person's name (required)",
+                },
+                nickname: {
+                    type: "string",
+                    description: "Nickname or alias (optional)",
+                },
+                relationshipType: {
+                    type: "string",
+                    enum: ["family", "friend", "colleague", "acquaintance", "mentor", "other"],
+                    description: "Relationship type (optional)",
+                },
+                avatarEmoji: {
+                    type: "string",
+                    description: "Emoji to represent this person (optional)",
+                },
+                notes: {
+                    type: "string",
+                    description: "User notes about this person (optional)",
+                },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "update_person",
+        description: "Update a contact's details.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                personId: {
+                    type: "string",
+                    description: "The person's ID (required)",
+                },
+                name: {
+                    type: "string",
+                    description: "Updated name (optional)",
+                },
+                nickname: {
+                    type: "string",
+                    description: "Updated nickname (optional)",
+                },
+                relationshipType: {
+                    type: "string",
+                    enum: ["family", "friend", "colleague", "acquaintance", "mentor", "other"],
+                    description: "Updated relationship type (optional)",
+                },
+                email: {
+                    type: "string",
+                    description: "Email address (optional)",
+                },
+                phone: {
+                    type: "string",
+                    description: "Phone number (optional)",
+                },
+                notes: {
+                    type: "string",
+                    description: "Updated notes (optional)",
+                },
+            },
+            required: ["personId"],
+        },
+    },
+    {
+        name: "link_memo_to_person",
+        description: "Link a voice memo to a person.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                personId: {
+                    type: "string",
+                    description: "The person's ID (required)",
+                },
+                voiceMemoId: {
+                    type: "string",
+                    description: "The voice memo's ID (required)",
+                },
+                context: {
+                    type: "string",
+                    description: "Context for the link, e.g., 'Phone call', 'Coffee meetup' (optional)",
+                },
+            },
+            required: ["personId", "voiceMemoId"],
+        },
+    },
+    // Client Management Tools
+    {
+        name: "get_clients",
+        description: "Get all clients for consulting/freelance work with optional status filter.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                status: {
+                    type: "string",
+                    enum: ["active", "archived"],
+                    description: "Filter by status (optional)",
+                },
+            },
+        },
+    },
+    {
+        name: "get_client",
+        description: "Get a single client's details with project statistics.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                clientId: {
+                    type: "string",
+                    description: "The client's ID (required)",
+                },
+            },
+            required: ["clientId"],
+        },
+    },
+    {
+        name: "get_projects_for_client",
+        description: "Get all projects associated with a client, including completion stats.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                clientId: {
+                    type: "string",
+                    description: "The client's ID (required)",
+                },
+            },
+            required: ["clientId"],
+        },
+    },
+    {
+        name: "create_client",
+        description: "Create a new client for consulting/freelance work.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "The client's name (required)",
+                },
+                description: {
+                    type: "string",
+                    description: "Description of the client (optional)",
+                },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "update_client",
+        description: "Update a client's details.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                clientId: {
+                    type: "string",
+                    description: "The client's ID (required)",
+                },
+                name: {
+                    type: "string",
+                    description: "Updated name (optional)",
+                },
+                description: {
+                    type: "string",
+                    description: "Updated description (optional)",
+                },
+                status: {
+                    type: "string",
+                    enum: ["active", "archived"],
+                    description: "Updated status (optional)",
+                },
+            },
+            required: ["clientId"],
+        },
+    },
+    // Phase Management Tools
+    {
+        name: "get_phases",
+        description: "Get all phases for a project with issue stats. Use this to see project breakdown by phases.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                projectId: {
+                    type: "string",
+                    description: "The project's ID (required)",
+                },
+            },
+            required: ["projectId"],
+        },
+    },
+    {
+        name: "get_phase",
+        description: "Get a single phase with its issues. Use this to see phase details and issues assigned to it.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                phaseId: {
+                    type: "string",
+                    description: "The phase's ID (required)",
+                },
+            },
+            required: ["phaseId"],
+        },
+    },
+    {
+        name: "create_phase",
+        description: "Create a new phase in a project. Use this to organize project work into distinct stages.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                projectId: {
+                    type: "string",
+                    description: "The project's ID (required)",
+                },
+                name: {
+                    type: "string",
+                    description: "The phase name (required)",
+                },
+                description: {
+                    type: "string",
+                    description: "Phase description, markdown supported (optional)",
+                },
+                status: {
+                    type: "string",
+                    enum: ["not_started", "in_progress", "completed"],
+                    description: "Phase status (optional, default: not_started)",
+                },
+            },
+            required: ["projectId", "name"],
+        },
+    },
+    {
+        name: "update_phase",
+        description: "Update a phase's details.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                phaseId: {
+                    type: "string",
+                    description: "The phase's ID (required)",
+                },
+                name: {
+                    type: "string",
+                    description: "Updated name (optional)",
+                },
+                description: {
+                    type: "string",
+                    description: "Updated description (optional)",
+                },
+                status: {
+                    type: "string",
+                    enum: ["not_started", "in_progress", "completed"],
+                    description: "Updated status (optional)",
+                },
+                startDate: {
+                    type: "string",
+                    description: "Start date in ISO format (optional)",
+                },
+                endDate: {
+                    type: "string",
+                    description: "End date in ISO format (optional)",
+                },
+            },
+            required: ["phaseId"],
+        },
+    },
+    {
+        name: "delete_phase",
+        description: "Delete a phase. Issues in the phase are unlinked (not deleted).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                phaseId: {
+                    type: "string",
+                    description: "The phase's ID (required)",
+                },
+            },
+            required: ["phaseId"],
+        },
+    },
+    {
+        name: "assign_issue_to_phase",
+        description: "Assign an issue to a phase, or unassign by omitting phaseId.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                issueIdOrIdentifier: {
+                    type: "string",
+                    description: "Issue ID or identifier like PROJ-123 (required)",
+                },
+                phaseId: {
+                    type: "string",
+                    description: "Phase ID (optional - omit to unassign from current phase)",
+                },
+            },
+            required: ["issueIdOrIdentifier"],
+        },
+    },
+];
+// Configuration: CLI flags take precedence over env vars
+// NOTE: HTTP routes are served from .convex.site, NOT .convex.cloud
+const CONVEX_URL = options.url || process.env.CONVEX_URL;
+const API_KEY = options.apiKey || process.env.LIFEOS_API_KEY;
+const USER_ID = options.userId || process.env.LIFEOS_USER_ID;
+// Validate required configuration
+const missingConfig = [];
+if (!CONVEX_URL)
+    missingConfig.push("CONVEX_URL (--url or CONVEX_URL env)");
+if (!API_KEY)
+    missingConfig.push("API_KEY (--api-key or LIFEOS_API_KEY env)");
+if (!USER_ID)
+    missingConfig.push("USER_ID (--user-id or LIFEOS_USER_ID env)");
+if (missingConfig.length > 0) {
+    console.error("Error: Missing required configuration:");
+    missingConfig.forEach((c) => console.error(`  - ${c}`));
+    console.error("");
+    console.error("Example usage:");
+    console.error("  lifeos-mcp --url https://your-app.convex.site --user-id xxx --api-key yyy");
+    console.error("");
+    console.error("Or with environment variables:");
+    console.error("  CONVEX_URL=https://your-app.convex.site LIFEOS_USER_ID=xxx LIFEOS_API_KEY=yyy lifeos-mcp");
+    process.exit(1);
+}
+/**
+ * Call the Convex /tool-call HTTP endpoint
+ */
+async function callConvexTool(tool, params) {
+    const url = `${CONVEX_URL}/tool-call`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "X-API-Key": API_KEY,
+        },
+        body: JSON.stringify({
+            tool,
+            userId: USER_ID,
+            params,
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Convex API error (${response.status}): ${errorText}`);
+    }
+    const result = await response.json();
+    if (!result.success && result.error) {
+        throw new Error(result.error);
+    }
+    return result.result;
+}
+// Create the MCP server
+const server = new Server({
+    name: "lifeos-pm",
+    version: "0.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Handle list tools request
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
+});
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        const result = await callConvexTool(name, args || {});
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${errorMessage}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Start the server with stdio transport
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("LifeOS MCP server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@starascendin/lifeos-mcp",
+  "version": "0.1.0",
+  "description": "MCP server for LifeOS Project Management - manage projects, tasks, notes, and contacts via AI assistants",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "lifeos-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build",
+    "version:patch": "npm version patch",
+    "version:minor": "npm version minor",
+    "version:major": "npm version major"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "lifeos",
+    "project-management",
+    "ai",
+    "claude",
+    "convex"
+  ],
+  "author": "Bryan Liu",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bryanliu/lifeos-mcp"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "commander": "^14.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  }
+}