slyplan-mcp 1.0.0

package/dist/db.d.ts

@@ -0,0 +1,30 @@
+import type { TreeNode, Link } from './types.js';
+export declare function getTree(rootId?: string | null): Promise<TreeNode[]>;
+export declare function getNode(id: string): Promise<TreeNode | null>;
+export declare function insertNode(data: {
+    parentId: string | null;
+    type: string;
+    title: string;
+    description?: string;
+    status?: string;
+    progress?: number;
+    metadata?: Record<string, unknown>;
+}): Promise<TreeNode>;
+export declare function updateNode(id: string, updates: {
+    title?: string;
+    description?: string;
+    status?: string;
+    progress?: number;
+    collapsed?: boolean;
+    metadata?: Record<string, unknown>;
+}): Promise<TreeNode | null>;
+export declare function deleteNode(id: string): Promise<boolean>;
+export declare function moveNode(id: string, newParentId: string | null, sortOrder?: number): Promise<TreeNode | null>;
+export declare function addLink(nodeId: string, url: string, label?: string, linkType?: string): Promise<Link>;
+export declare function getWorkMode(): Promise<TreeNode[]>;
+export declare function addToWorkMode(nodeId: string): Promise<boolean>;
+export declare function removeFromWorkMode(nodeId: string): Promise<boolean>;
+export declare function searchNodes(query: string, filters?: {
+    type?: string[];
+    status?: string[];
+}): Promise<TreeNode[]>;

package/dist/db.js

@@ -0,0 +1,305 @@
+import { supabase, getUserId } from './supabase.js';
+import { v4 as uuid } from 'uuid';
+function dbNodeToTree(row, links, children) {
+    return {
+        id: row.id,
+        parentId: row.parent_id,
+        type: row.type,
+        title: row.title,
+        description: row.description,
+        status: row.status,
+        progress: row.progress,
+        sortOrder: row.sort_order,
+        collapsed: row.collapsed,
+        metadata: row.metadata || {},
+        links,
+        children,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+    };
+}
+function dbLinkToLink(row) {
+    return {
+        id: row.id,
+        nodeId: row.node_id,
+        url: row.url,
+        label: row.label,
+        linkType: row.link_type,
+        createdAt: row.created_at,
+    };
+}
+// --- Node CRUD ---
+export async function getTree(rootId) {
+    const { data: allNodes, error: nodesErr } = await supabase
+        .from('nodes')
+        .select('*')
+        .order('sort_order', { ascending: true });
+    if (nodesErr)
+        throw new Error(nodesErr.message);
+    const { data: allLinks, error: linksErr } = await supabase
+        .from('links')
+        .select('*');
+    if (linksErr)
+        throw new Error(linksErr.message);
+    const linksByNode = new Map();
+    for (const link of allLinks || []) {
+        const arr = linksByNode.get(link.node_id) || [];
+        arr.push(dbLinkToLink(link));
+        linksByNode.set(link.node_id, arr);
+    }
+    const nodeMap = new Map();
+    const childrenMap = new Map();
+    for (const node of (allNodes || [])) {
+        nodeMap.set(node.id, node);
+        const parentKey = node.parent_id;
+        const arr = childrenMap.get(parentKey) || [];
+        arr.push(node);
+        childrenMap.set(parentKey, arr);
+    }
+    function buildSubtree(parentId) {
+        const children = childrenMap.get(parentId) || [];
+        return children.map(node => {
+            const subtreeChildren = buildSubtree(node.id);
+            const links = linksByNode.get(node.id) || [];
+            let progress = node.progress;
+            if (subtreeChildren.length > 0) {
+                const total = subtreeChildren.reduce((sum, c) => sum + c.progress, 0);
+                progress = Math.round(total / subtreeChildren.length);
+            }
+            return dbNodeToTree({ ...node, progress }, links, subtreeChildren);
+        });
+    }
+    if (rootId) {
+        const rootNode = nodeMap.get(rootId);
+        if (!rootNode)
+            return [];
+        const children = buildSubtree(rootId);
+        let progress = rootNode.progress;
+        if (children.length > 0) {
+            progress = Math.round(children.reduce((sum, c) => sum + c.progress, 0) / children.length);
+        }
+        return [dbNodeToTree({ ...rootNode, progress }, linksByNode.get(rootId) || [], children)];
+    }
+    return buildSubtree(null);
+}
+export async function getNode(id) {
+    const { data: row, error } = await supabase
+        .from('nodes')
+        .select('*')
+        .eq('id', id)
+        .single();
+    if (error || !row)
+        return null;
+    const { data: linkRows } = await supabase
+        .from('links')
+        .select('*')
+        .eq('node_id', id);
+    const links = (linkRows || []).map(dbLinkToLink);
+    const { data: childRows } = await supabase
+        .from('nodes')
+        .select('*')
+        .eq('parent_id', id)
+        .order('sort_order', { ascending: true });
+    const children = [];
+    for (const child of (childRows || [])) {
+        const { data: childLinkRows } = await supabase
+            .from('links')
+            .select('*')
+            .eq('node_id', child.id);
+        children.push(dbNodeToTree(child, (childLinkRows || []).map(dbLinkToLink), []));
+    }
+    let progress = row.progress;
+    if (children.length > 0) {
+        progress = Math.round(children.reduce((sum, c) => sum + c.progress, 0) / children.length);
+    }
+    return dbNodeToTree({ ...row, progress }, links, children);
+}
+export async function insertNode(data) {
+    const id = uuid();
+    let maxOrder = -1;
+    if (data.parentId === null) {
+        const { data: rootRows } = await supabase
+            .from('nodes')
+            .select('sort_order')
+            .is('parent_id', null)
+            .order('sort_order', { ascending: false })
+            .limit(1);
+        maxOrder = rootRows && rootRows.length > 0 ? rootRows[0].sort_order : -1;
+    }
+    else {
+        const { data: rows } = await supabase
+            .from('nodes')
+            .select('sort_order')
+            .eq('parent_id', data.parentId)
+            .order('sort_order', { ascending: false })
+            .limit(1);
+        maxOrder = rows && rows.length > 0 ? rows[0].sort_order : -1;
+    }
+    const { error } = await supabase.from('nodes').insert({
+        id,
+        parent_id: data.parentId,
+        type: data.type,
+        title: data.title,
+        description: data.description || '',
+        status: data.status || 'not_started',
+        progress: data.progress || 0,
+        sort_order: maxOrder + 1,
+        metadata: data.metadata || {},
+        created_by: getUserId(),
+    });
+    if (error)
+        throw new Error(error.message);
+    return (await getNode(id));
+}
+export async function updateNode(id, updates) {
+    const { data: existing } = await supabase
+        .from('nodes')
+        .select('id')
+        .eq('id', id)
+        .single();
+    if (!existing)
+        return null;
+    const fields = {};
+    if (updates.title !== undefined)
+        fields.title = updates.title;
+    if (updates.description !== undefined)
+        fields.description = updates.description;
+    if (updates.status !== undefined)
+        fields.status = updates.status;
+    if (updates.progress !== undefined)
+        fields.progress = updates.progress;
+    if (updates.collapsed !== undefined)
+        fields.collapsed = updates.collapsed;
+    if (updates.metadata !== undefined)
+        fields.metadata = updates.metadata;
+    if (Object.keys(fields).length === 0)
+        return getNode(id);
+    const { error } = await supabase
+        .from('nodes')
+        .update(fields)
+        .eq('id', id);
+    if (error)
+        throw new Error(error.message);
+    return getNode(id);
+}
+export async function deleteNode(id) {
+    const { data: existing } = await supabase
+        .from('nodes')
+        .select('id')
+        .eq('id', id)
+        .single();
+    if (!existing)
+        return false;
+    const { error } = await supabase.from('nodes').delete().eq('id', id);
+    if (error)
+        throw new Error(error.message);
+    return true;
+}
+export async function moveNode(id, newParentId, sortOrder) {
+    const { data: existing } = await supabase
+        .from('nodes')
+        .select('id')
+        .eq('id', id)
+        .single();
+    if (!existing)
+        return null;
+    let order = sortOrder;
+    if (order === undefined) {
+        if (newParentId === null) {
+            const { data: rootRows } = await supabase
+                .from('nodes')
+                .select('sort_order')
+                .is('parent_id', null)
+                .order('sort_order', { ascending: false })
+                .limit(1);
+            order = rootRows && rootRows.length > 0 ? rootRows[0].sort_order + 1 : 0;
+        }
+        else {
+            const { data: rows } = await supabase
+                .from('nodes')
+                .select('sort_order')
+                .eq('parent_id', newParentId)
+                .order('sort_order', { ascending: false })
+                .limit(1);
+            order = rows && rows.length > 0 ? rows[0].sort_order + 1 : 0;
+        }
+    }
+    const { error } = await supabase
+        .from('nodes')
+        .update({ parent_id: newParentId, sort_order: order })
+        .eq('id', id);
+    if (error)
+        throw new Error(error.message);
+    return getNode(id);
+}
+// --- Links ---
+export async function addLink(nodeId, url, label, linkType) {
+    const id = uuid();
+    const { error } = await supabase.from('links').insert({
+        id,
+        node_id: nodeId,
+        url,
+        label: label || '',
+        link_type: linkType || 'reference',
+    });
+    if (error)
+        throw new Error(error.message);
+    return { id, nodeId, url, label: label || '', linkType: linkType || 'reference', createdAt: new Date().toISOString() };
+}
+// --- Work Mode ---
+export async function getWorkMode() {
+    const { data: wmRows } = await supabase
+        .from('work_mode')
+        .select('node_id')
+        .eq('user_id', getUserId())
+        .order('added_at', { ascending: true });
+    if (!wmRows || wmRows.length === 0)
+        return [];
+    const nodeIds = wmRows.map(r => r.node_id);
+    const { data: nodeRows } = await supabase
+        .from('nodes')
+        .select('*')
+        .in('id', nodeIds);
+    const results = [];
+    for (const row of (nodeRows || [])) {
+        const { data: linkRows } = await supabase
+            .from('links')
+            .select('*')
+            .eq('node_id', row.id);
+        results.push(dbNodeToTree(row, (linkRows || []).map(dbLinkToLink), []));
+    }
+    return results;
+}
+export async function addToWorkMode(nodeId) {
+    const { error } = await supabase
+        .from('work_mode')
+        .upsert({ node_id: nodeId, user_id: getUserId() }, { onConflict: 'node_id,user_id' });
+    return !error;
+}
+export async function removeFromWorkMode(nodeId) {
+    const { error } = await supabase
+        .from('work_mode')
+        .delete()
+        .eq('node_id', nodeId)
+        .eq('user_id', getUserId());
+    return !error;
+}
+// --- Search ---
+export async function searchNodes(query, filters) {
+    let q = supabase
+        .from('nodes')
+        .select('*')
+        .or(`title.ilike.%${query}%,description.ilike.%${query}%`)
+        .order('sort_order', { ascending: true })
+        .limit(50);
+    if (filters?.type && filters.type.length > 0) {
+        q = q.in('type', filters.type);
+    }
+    if (filters?.status && filters.status.length > 0) {
+        q = q.in('status', filters.status);
+    }
+    const { data: rows, error } = await q;
+    if (error)
+        throw new Error(error.message);
+    return (rows || []).map(row => dbNodeToTree(row, [], []));
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { authenticate, supabase } from './supabase.js';
+import { getTree, getNode, insertNode, updateNode, deleteNode, moveNode, searchNodes, getWorkMode } from './db.js';
+const server = new McpServer({
+    name: 'slyplan',
+    version: '1.0.0',
+});
+// --- Session state ---
+let activeProjectId = null;
+async function getActiveProjectName() {
+    if (!activeProjectId)
+        return '(none)';
+    const node = await getNode(activeProjectId);
+    return node ? node.title : '(unknown)';
+}
+function resolveParentId(parentId) {
+    if (parentId !== undefined && parentId !== null)
+        return parentId;
+    return activeProjectId;
+}
+// --- Tools ---
+server.tool('list_projects', 'List all projects. Use this first to see available projects.', {}, async () => {
+    const tree = await getTree(null);
+    const projects = tree.filter(n => n.type === 'project');
+    const lines = projects.map(p => {
+        const active = p.id === activeProjectId ? ' ← ACTIVE' : '';
+        return `• ${p.title} (${p.status}, ${p.progress}%) [${p.id}]${active}`;
+    });
+    const header = activeProjectId
+        ? `Active project: ${await getActiveProjectName()}`
+        : 'No active project selected. Use set_project to choose one.';
+    return {
+        content: [{ type: 'text', text: `${header}\n\nProjects:\n${lines.join('\n') || '(no projects)'}` }],
+    };
+});
+server.tool('set_project', 'Select which project to work in. All subsequent operations (add_node, get_tree, search) will apply to this project.', {
+    project_id: z.string().describe('Project ID to work in. Get from list_projects.'),
+}, async ({ project_id }) => {
+    const node = await getNode(project_id);
+    if (!node)
+        return { content: [{ type: 'text', text: 'Project not found.' }], isError: true };
+    if (node.type !== 'project')
+        return { content: [{ type: 'text', text: `"${node.title}" is a ${node.type}, not a project.` }], isError: true };
+    activeProjectId = project_id;
+    return {
+        content: [{ type: 'text', text: `Active project set to: "${node.title}"\n\nAll add_node, get_tree and search operations will now apply to this project.\nUse get_tree to see the project structure.` }],
+    };
+});
+server.tool('get_tree', 'Get the project tree. Shows the active project if set, or the full tree.', { root_id: z.string().optional().describe('Node ID to use as root. Omit for active project / full tree.') }, async ({ root_id }) => {
+    const effectiveRoot = root_id ?? activeProjectId ?? null;
+    const tree = await getTree(effectiveRoot);
+    const ctx = activeProjectId ? `Project: ${await getActiveProjectName()}\n\n` : '';
+    return { content: [{ type: 'text', text: `${ctx}${JSON.stringify(tree, null, 2)}` }] };
+});
+server.tool('get_node', 'Get details about a single node', { id: z.string().describe('Node ID to fetch') }, async ({ id }) => {
+    const node = await getNode(id);
+    if (!node)
+        return { content: [{ type: 'text', text: 'Node not found' }], isError: true };
+    return { content: [{ type: 'text', text: JSON.stringify(node, null, 2) }] };
+});
+server.tool('add_node', 'Add a new node. If parent_id is not set, the node is added under the active project.', {
+    parent_id: z.string().nullable().optional().describe('Parent ID. Omit to use active project as parent.'),
+    type: z.enum(['project', 'category', 'module', 'component', 'feature', 'task']).describe('Node type'),
+    title: z.string().describe('Node title'),
+    description: z.string().optional().describe('Description'),
+    status: z.enum(['not_started', 'in_progress', 'blocked', 'done']).optional().describe('Status'),
+    progress: z.number().min(0).max(100).optional().describe('Progress percentage (0-100)'),
+    metadata: z.record(z.unknown()).optional().describe('Extra metadata as JSON'),
+}, async ({ parent_id, type, title, description, status, progress, metadata }) => {
+    try {
+        const effectiveParent = type === 'project' ? null : resolveParentId(parent_id);
+        const node = await insertNode({
+            parentId: effectiveParent,
+            type, title, description, status, progress, metadata,
+        });
+        const parentNode = effectiveParent ? await getNode(effectiveParent) : null;
+        return { content: [{ type: 'text', text: `Node created under ${parentNode ? `"${parentNode.title}"` : 'root'}:\n${JSON.stringify(node, null, 2)}` }] };
+    }
+    catch (e) {
+        return { content: [{ type: 'text', text: `Error: ${e.message}` }], isError: true };
+    }
+});
+server.tool('update_node', 'Update fields on an existing node', {
+    id: z.string().describe('Node ID to update'),
+    title: z.string().optional().describe('New title'),
+    description: z.string().optional().describe('New description'),
+    status: z.enum(['not_started', 'in_progress', 'blocked', 'done']).optional().describe('New status'),
+    progress: z.number().min(0).max(100).optional().describe('New progress (0-100)'),
+    metadata: z.record(z.unknown()).optional().describe('New metadata'),
+}, async ({ id, ...updates }) => {
+    const node = await updateNode(id, updates);
+    if (!node)
+        return { content: [{ type: 'text', text: 'Node not found' }], isError: true };
+    return { content: [{ type: 'text', text: `Node updated:\n${JSON.stringify(node, null, 2)}` }] };
+});
+server.tool('move_node', 'Move a node to a new parent', {
+    id: z.string().describe('Node ID to move'),
+    new_parent_id: z.string().nullable().describe('New parent ID (null for root level)'),
+    sort_order: z.number().optional().describe('Position among siblings'),
+}, async ({ id, new_parent_id, sort_order }) => {
+    const node = await moveNode(id, new_parent_id, sort_order);
+    if (!node)
+        return { content: [{ type: 'text', text: 'Node not found' }], isError: true };
+    return { content: [{ type: 'text', text: `Node moved:\n${JSON.stringify(node, null, 2)}` }] };
+});
+server.tool('delete_node', 'Delete a node and all its children', {
+    id: z.string().describe('Node ID to delete'),
+}, async ({ id }) => {
+    const node = await getNode(id);
+    if (!node)
+        return { content: [{ type: 'text', text: 'Node not found' }], isError: true };
+    await deleteNode(id);
+    return { content: [{ type: 'text', text: `Deleted node "${node.title}" (${id}) and all children.` }] };
+});
+server.tool('search', 'Search for nodes by text, type and status. Searches in active project if set.', {
+    query: z.string().describe('Search term for title/description'),
+    type: z.enum(['project', 'category', 'module', 'component', 'feature', 'task']).optional().describe('Filter by type'),
+    status: z.enum(['not_started', 'in_progress', 'blocked', 'done']).optional().describe('Filter by status'),
+}, async ({ query, type, status }) => {
+    const results = await searchNodes(query, {
+        type: type ? [type] : undefined,
+        status: status ? [status] : undefined,
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: results.length > 0
+                    ? `Found ${results.length} results:\n${JSON.stringify(results, null, 2)}`
+                    : 'No results found.',
+            }],
+    };
+});
+server.tool('get_work_mode', 'Get all nodes currently in Work Mode', {}, async () => {
+    const items = await getWorkMode();
+    return {
+        content: [{
+                type: 'text',
+                text: items.length > 0
+                    ? `Work Mode (${items.length} active):\n${JSON.stringify(items, null, 2)}`
+                    : 'No nodes in Work Mode.',
+            }],
+    };
+});
+server.tool('request_completion', 'Analyze a node and suggest completion based on children status', {
+    id: z.string().describe('Node ID to analyze'),
+    context: z.string().optional().describe('Extra context about what was done'),
+}, async ({ id, context }) => {
+    const node = await getNode(id);
+    if (!node)
+        return { content: [{ type: 'text', text: 'Node not found' }], isError: true };
+    const children = node.children;
+    const summary = {
+        node: { id: node.id, title: node.title, type: node.type, status: node.status, progress: node.progress },
+        children_summary: {
+            total: children.length,
+            done: children.filter(c => c.status === 'done').length,
+            in_progress: children.filter(c => c.status === 'in_progress').length,
+            blocked: children.filter(c => c.status === 'blocked').length,
+            not_started: children.filter(c => c.status === 'not_started').length,
+        },
+        suggested_progress: children.length > 0
+            ? Math.round(children.reduce((sum, c) => sum + c.progress, 0) / children.length)
+            : node.progress,
+        context: context || 'No extra context',
+    };
+    const allDone = children.length > 0 && children.every(c => c.status === 'done');
+    return {
+        content: [{
+                type: 'text',
+                text: allDone
+                    ? `All ${children.length} children are done! Node "${node.title}" can be marked as done.\n\n${JSON.stringify(summary, null, 2)}`
+                    : `Analysis of "${node.title}":\n${JSON.stringify(summary, null, 2)}`,
+            }],
+    };
+});
+server.tool('whoami', 'Show which user is authenticated for this MCP session.', {}, async () => {
+    const { data: { user } } = await supabase.auth.getUser();
+    if (!user)
+        return { content: [{ type: 'text', text: 'Not authenticated.' }], isError: true };
+    return {
+        content: [{ type: 'text', text: `Authenticated as: ${user.email} (${user.id})` }],
+    };
+});
+// --- Start ---
+async function main() {
+    await authenticate();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch(console.error);

package/dist/supabase.d.ts

@@ -0,0 +1,3 @@
+export declare const supabase: import("@supabase/supabase-js").SupabaseClient<any, "public", "public", any, any>;
+export declare function authenticate(): Promise<void>;
+export declare function getUserId(): string;

package/dist/supabase.js

@@ -0,0 +1,27 @@
+import { createClient } from '@supabase/supabase-js';
+const SUPABASE_URL = 'https://omfzpkwtuzucwwxmyuqt.supabase.co';
+const SUPABASE_ANON_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im9tZnpwa3d0dXp1Y3d3eG15dXF0Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzA5MjMwNDIsImV4cCI6MjA4NjQ5OTA0Mn0.KXGoUez7M45RtFM9qR7mjzGX6UhlaRE-gggAJxSkIHY';
+export const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
+    auth: { autoRefreshToken: true, persistSession: false },
+});
+let userId = null;
+export async function authenticate() {
+    const email = process.env.SLYPLAN_EMAIL;
+    const password = process.env.SLYPLAN_PASSWORD;
+    if (!email || !password) {
+        console.error('Missing SLYPLAN_EMAIL or SLYPLAN_PASSWORD environment variables.');
+        console.error('Set them in your Claude MCP config under "env".');
+        process.exit(1);
+    }
+    const { data, error } = await supabase.auth.signInWithPassword({ email, password });
+    if (error) {
+        console.error(`Authentication failed: ${error.message}`);
+        process.exit(1);
+    }
+    userId = data.user.id;
+}
+export function getUserId() {
+    if (!userId)
+        throw new Error('Not authenticated. Call authenticate() first.');
+    return userId;
+}

package/dist/types.d.ts

@@ -0,0 +1,26 @@
+export type NodeType = 'project' | 'category' | 'module' | 'component' | 'feature' | 'task';
+export type Status = 'not_started' | 'in_progress' | 'blocked' | 'done';
+export interface TreeNode {
+    id: string;
+    parentId: string | null;
+    type: NodeType;
+    title: string;
+    description: string;
+    status: Status;
+    progress: number;
+    sortOrder: number;
+    collapsed: boolean;
+    metadata: Record<string, unknown>;
+    links: Link[];
+    children: TreeNode[];
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Link {
+    id: string;
+    nodeId: string;
+    url: string;
+    label: string;
+    linkType: string;
+    createdAt: string;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "slyplan-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for Slyplan — visual project management via Claude",
+  "type": "module",
+  "bin": {
+    "slyplan-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "slyplan",
+    "project-management",
+    "claude",
+    "ai"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@supabase/supabase-js": "^2.78.0",
+    "uuid": "^11.0.5",
+    "zod": "^3.25.0"
+  },
+  "devDependencies": {
+    "@types/uuid": "^10.0.0",
+    "typescript": "^5.7.3"
+  }
+}