claudit 0.1.0

package/server/dist/server/src/services/managedSessions.js

@@ -0,0 +1,96 @@
+import { db } from './database.js';
+// --- Prepared statements ---
+const stmtAll = db.prepare('SELECT * FROM managed_sessions');
+const stmtById = db.prepare('SELECT * FROM managed_sessions WHERE sessionId = ?');
+const stmtInsert = db.prepare(`
+  INSERT INTO managed_sessions (sessionId, projectPath, displayName, archived, pinned, createdAt)
+  VALUES (@sessionId, @projectPath, @displayName, @archived, @pinned, @createdAt)
+`);
+const stmtDelete = db.prepare('DELETE FROM managed_sessions WHERE sessionId = ?');
+const stmtUpsertArchive = db.prepare(`
+  INSERT INTO managed_sessions (sessionId, projectPath, displayName, archived, pinned, createdAt)
+  VALUES (@sessionId, '', NULL, @archived, 0, @createdAt)
+  ON CONFLICT(sessionId) DO UPDATE SET archived = @archived
+`);
+const stmtUpsertPin = db.prepare(`
+  INSERT INTO managed_sessions (sessionId, projectPath, displayName, archived, pinned, createdAt)
+  VALUES (@sessionId, '', NULL, 0, @pinned, @createdAt)
+  ON CONFLICT(sessionId) DO UPDATE SET pinned = @pinned
+`);
+const stmtRename = db.prepare('UPDATE managed_sessions SET displayName = ? WHERE sessionId = ?');
+const stmtPinned = db.prepare('SELECT sessionId FROM managed_sessions WHERE pinned = 1');
+const stmtArchived = db.prepare('SELECT sessionId FROM managed_sessions WHERE archived = 1');
+// --- Row mapper ---
+function rowToSession(row) {
+    const s = {
+        sessionId: row.sessionId,
+        projectPath: row.projectPath,
+        createdAt: row.createdAt,
+    };
+    if (row.displayName != null)
+        s.displayName = row.displayName;
+    if (row.archived === 1)
+        s.archived = true;
+    if (row.pinned === 1)
+        s.pinned = true;
+    return s;
+}
+export function getManagedSessions() {
+    return stmtAll.all().map(rowToSession);
+}
+export function addManagedSession(sessionId, projectPath) {
+    const entry = {
+        sessionId,
+        projectPath,
+        createdAt: new Date().toISOString(),
+    };
+    stmtInsert.run({
+        sessionId,
+        projectPath,
+        displayName: null,
+        archived: 0,
+        pinned: 0,
+        createdAt: entry.createdAt,
+    });
+    return entry;
+}
+export function renameManagedSession(sessionId, name) {
+    const result = stmtRename.run(name, sessionId);
+    if (result.changes === 0)
+        return null;
+    const row = stmtById.get(sessionId);
+    return row ? rowToSession(row) : null;
+}
+export function archiveManagedSession(sessionId, archived) {
+    stmtUpsertArchive.run({
+        sessionId,
+        archived: archived ? 1 : 0,
+        createdAt: new Date().toISOString(),
+    });
+}
+export function removeManagedSession(sessionId) {
+    stmtDelete.run(sessionId);
+}
+export function pinManagedSession(sessionId, pinned) {
+    stmtUpsertPin.run({
+        sessionId,
+        pinned: pinned ? 1 : 0,
+        createdAt: new Date().toISOString(),
+    });
+}
+export function getPinnedSessionIds() {
+    const rows = stmtPinned.all();
+    return new Set(rows.map(r => r.sessionId));
+}
+export function getArchivedSessionIds() {
+    const rows = stmtArchived.all();
+    return new Set(rows.map(r => r.sessionId));
+}
+/** Returns Map<sessionId, ManagedSession> for fast lookup */
+export function getManagedSessionMap() {
+    const map = new Map();
+    for (const s of getManagedSessions()) {
+        map.set(s.sessionId, s);
+    }
+    return map;
+}

package/server/dist/server/src/services/providerConfigStorage.js

@@ -0,0 +1,80 @@
+import crypto from 'crypto';
+import { db } from './database.js';
+// --- Prepared statements ---
+const stmtAll = db.prepare('SELECT * FROM provider_configs');
+const stmtById = db.prepare('SELECT * FROM provider_configs WHERE id = ?');
+const stmtInsert = db.prepare(`
+  INSERT INTO provider_configs (id, providerId, name, enabled, config, syncIntervalMinutes, lastSyncAt, lastSyncError, createdAt)
+  VALUES (@id, @providerId, @name, @enabled, @config, @syncIntervalMinutes, @lastSyncAt, @lastSyncError, @createdAt)
+`);
+const stmtDelete = db.prepare('DELETE FROM provider_configs WHERE id = ?');
+// --- Row mapper ---
+function rowToConfig(row) {
+    const config = {
+        id: row.id,
+        providerId: row.providerId,
+        name: row.name,
+        enabled: row.enabled === 1,
+        config: JSON.parse(row.config),
+        createdAt: row.createdAt,
+    };
+    if (row.syncIntervalMinutes != null)
+        config.syncIntervalMinutes = row.syncIntervalMinutes;
+    if (row.lastSyncAt != null)
+        config.lastSyncAt = row.lastSyncAt;
+    if (row.lastSyncError != null)
+        config.lastSyncError = row.lastSyncError;
+    return config;
+}
+function configToParams(config) {
+    return {
+        id: config.id,
+        providerId: config.providerId,
+        name: config.name,
+        enabled: config.enabled ? 1 : 0,
+        config: JSON.stringify(config.config),
+        syncIntervalMinutes: config.syncIntervalMinutes ?? null,
+        lastSyncAt: config.lastSyncAt ?? null,
+        lastSyncError: config.lastSyncError ?? null,
+        createdAt: config.createdAt,
+    };
+}
+/** Trim whitespace from all string values in config (prevents pasted keys with spaces) */
+function sanitizeConfig(config) {
+    const result = {};
+    for (const [key, value] of Object.entries(config)) {
+        result[key] = typeof value === 'string' ? value.replace(/\s+/g, '') : value;
+    }
+    return result;
+}
+export function getAllConfigs() {
+    return stmtAll.all().map(rowToConfig);
+}
+export function getConfig(id) {
+    const row = stmtById.get(id);
+    return row ? rowToConfig(row) : undefined;
+}
+export function createConfig(data) {
+    const config = {
+        ...data,
+        config: sanitizeConfig(data.config),
+        id: crypto.randomUUID(),
+        createdAt: new Date().toISOString(),
+    };
+    stmtInsert.run(configToParams(config));
+    return config;
+}
+export function updateConfig(id, updates) {
+    const existing = getConfig(id);
+    if (!existing)
+        return null;
+    const sanitized = updates.config ? { ...updates, config: sanitizeConfig(updates.config) } : updates;
+    const merged = { ...existing, ...sanitized, id };
+    stmtDelete.run(id);
+    stmtInsert.run(configToParams(merged));
+    return merged;
+}
+export function deleteConfig(id) {
+    const result = stmtDelete.run(id);
+    return result.changes > 0;
+}

package/server/dist/server/src/services/providers/TodoProvider.js

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

package/server/dist/server/src/services/providers/larkDocsProvider.js

@@ -0,0 +1,75 @@
+import { callMcpTool } from './mcpClient.js';
+const configSchema = [
+    {
+        key: 'doc_token',
+        label: 'Document Token',
+        type: 'string',
+        required: true,
+        placeholder: 'e.g. doxcnXyz123 (from the doc URL)',
+    },
+];
+export const larkDocsProvider = {
+    id: 'lark-docs',
+    displayName: 'Lark Docs',
+    configSchema,
+    async fetchItems(config) {
+        const docToken = config.doc_token;
+        const result = await callMcpTool('lark-docs', 'get_lark_doc_content', {
+            doc_token: docToken,
+        });
+        const items = [];
+        // Parse document content to find checklist items
+        const content = result?.content?.[0]?.text || result?.text || '';
+        const text = typeof content === 'string' ? content : JSON.stringify(content);
+        // Parse checklist items from the document content
+        // Lark docs may return structured blocks or markdown-like text
+        const lines = text.split('\n');
+        let itemIndex = 0;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Match markdown-style checkboxes: - [ ] or - [x]
+            const checkboxMatch = trimmed.match(/^[-*]\s*\[([ xX])\]\s*(.+)/);
+            if (checkboxMatch) {
+                const completed = checkboxMatch[1].toLowerCase() === 'x';
+                const title = checkboxMatch[2].trim();
+                items.push({
+                    externalId: `${docToken}_${itemIndex++}`,
+                    externalUrl: `https://bytedance.larkoffice.com/docx/${docToken}`,
+                    title,
+                    completed,
+                    priority: 'medium',
+                });
+                continue;
+            }
+            // Match TODO/DONE markers
+            const todoMatch = trimmed.match(/^(?:TODO|TASK|ACTION):\s*(.+)/i);
+            if (todoMatch) {
+                items.push({
+                    externalId: `${docToken}_${itemIndex++}`,
+                    externalUrl: `https://bytedance.larkoffice.com/docx/${docToken}`,
+                    title: todoMatch[1].trim(),
+                    completed: false,
+                    priority: 'medium',
+                });
+                continue;
+            }
+            const doneMatch = trimmed.match(/^(?:DONE|COMPLETED|FINISHED):\s*(.+)/i);
+            if (doneMatch) {
+                items.push({
+                    externalId: `${docToken}_${itemIndex++}`,
+                    externalUrl: `https://bytedance.larkoffice.com/docx/${docToken}`,
+                    title: doneMatch[1].trim(),
+                    completed: true,
+                    priority: 'medium',
+                });
+            }
+        }
+        return items;
+    },
+    // completeItem not supported — Lark Docs is read-only for checklist parsing
+    async validateConfig(config) {
+        if (!config.doc_token)
+            return 'doc_token is required';
+        return null;
+    },
+};

package/server/dist/server/src/services/providers/mcpClient.js

@@ -0,0 +1,151 @@
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+const connections = new Map();
+/**
+ * Read MCP server configurations from Claude settings.
+ */
+function loadMcpConfig() {
+    const configs = {};
+    const settingsPath = path.join(process.env.HOME || '~', '.claude', 'settings.json');
+    try {
+        if (fs.existsSync(settingsPath)) {
+            const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+            if (settings.mcpServers) {
+                Object.assign(configs, settings.mcpServers);
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    // Also check project-level .mcp.json
+    const mcpJsonPath = path.join(process.cwd(), '.mcp.json');
+    try {
+        if (fs.existsSync(mcpJsonPath)) {
+            const mcpJson = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf-8'));
+            if (mcpJson.mcpServers) {
+                Object.assign(configs, mcpJson.mcpServers);
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return configs;
+}
+/**
+ * Connect to an MCP server via stdio JSON-RPC.
+ */
+function connectToServer(serverName) {
+    const existing = connections.get(serverName);
+    if (existing && existing.process.exitCode === null) {
+        return existing;
+    }
+    const configs = loadMcpConfig();
+    const serverConfig = configs[serverName];
+    if (!serverConfig) {
+        throw new Error(`MCP server "${serverName}" not found in configuration`);
+    }
+    const proc = spawn(serverConfig.command, serverConfig.args || [], {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: { ...process.env, ...serverConfig.env },
+    });
+    const conn = {
+        process: proc,
+        requestId: 0,
+        pending: new Map(),
+    };
+    let buffer = '';
+    proc.stdout.on('data', (chunk) => {
+        buffer += chunk.toString();
+        // Handle JSON-RPC messages separated by Content-Length headers or newlines
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || '';
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('Content-Length'))
+                continue;
+            try {
+                const msg = JSON.parse(trimmed);
+                if (msg.id !== undefined && conn.pending.has(msg.id)) {
+                    const p = conn.pending.get(msg.id);
+                    conn.pending.delete(msg.id);
+                    if (msg.error) {
+                        p.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+                    }
+                    else {
+                        p.resolve(msg.result);
+                    }
+                }
+            }
+            catch {
+                // not a JSON line, skip
+            }
+        }
+    });
+    proc.on('exit', () => {
+        // Reject all pending requests
+        for (const [, p] of conn.pending) {
+            p.reject(new Error(`MCP server "${serverName}" exited`));
+        }
+        conn.pending.clear();
+        connections.delete(serverName);
+    });
+    // Initialize the server
+    const initId = ++conn.requestId;
+    const initMsg = JSON.stringify({
+        jsonrpc: '2.0',
+        id: initId,
+        method: 'initialize',
+        params: {
+            protocolVersion: '2024-11-05',
+            capabilities: {},
+            clientInfo: { name: 'claudit', version: '1.0.0' },
+        },
+    });
+    proc.stdin.write(initMsg + '\n');
+    connections.set(serverName, conn);
+    return conn;
+}
+/**
+ * Call an MCP tool on the specified server.
+ */
+export async function callMcpTool(serverName, toolName, args) {
+    const conn = connectToServer(serverName);
+    const id = ++conn.requestId;
+    const request = JSON.stringify({
+        jsonrpc: '2.0',
+        id,
+        method: 'tools/call',
+        params: {
+            name: toolName,
+            arguments: args,
+        },
+    });
+    return new Promise((resolve, reject) => {
+        conn.pending.set(id, { resolve, reject });
+        conn.process.stdin.write(request + '\n');
+        // Timeout after 30 seconds
+        setTimeout(() => {
+            if (conn.pending.has(id)) {
+                conn.pending.delete(id);
+                reject(new Error(`MCP tool call "${toolName}" timed out`));
+            }
+        }, 30000);
+    });
+}
+/**
+ * Clean up all MCP connections on shutdown.
+ */
+export function closeMcpConnections() {
+    for (const [, conn] of connections) {
+        try {
+            conn.process.kill();
+        }
+        catch {
+            // ignore
+        }
+    }
+    connections.clear();
+}

package/server/dist/server/src/services/providers/meegoProvider.js

@@ -0,0 +1,99 @@
+import { callMcpTool } from './mcpClient.js';
+const configSchema = [
+    {
+        key: 'project_key',
+        label: 'Project Key',
+        type: 'string',
+        required: true,
+        placeholder: 'e.g. my-project',
+    },
+    {
+        key: 'work_item_type',
+        label: 'Work Item Type',
+        type: 'string',
+        required: true,
+        placeholder: 'e.g. story, task, bug',
+    },
+    {
+        key: 'moql_filter',
+        label: 'MOQL Filter (optional)',
+        type: 'string',
+        required: false,
+        placeholder: 'e.g. assignee = "me" AND status != "done"',
+    },
+];
+export const meegoProvider = {
+    id: 'meego',
+    displayName: 'Meego',
+    configSchema,
+    async fetchItems(config) {
+        const projectKey = config.project_key;
+        const workItemType = config.work_item_type;
+        const moqlFilter = config.moql_filter;
+        let mql = `project_key = "${projectKey}" AND work_item_type_key = "${workItemType}"`;
+        if (moqlFilter) {
+            mql += ` AND (${moqlFilter})`;
+        }
+        const result = await callMcpTool('meego', 'search_by_mql', {
+            project_key: projectKey,
+            work_item_type_key: workItemType,
+            mql,
+        });
+        const items = [];
+        // Parse the MCP result — expected to contain work items
+        const workItems = result?.content?.[0]?.text
+            ? JSON.parse(result.content[0].text)
+            : result?.work_items || result || [];
+        const list = Array.isArray(workItems) ? workItems : workItems.work_items || [];
+        for (const item of list) {
+            items.push({
+                externalId: String(item.id || item.work_item_id),
+                externalUrl: item.url || item.web_url,
+                title: item.name || item.title || item.summary || `Work Item ${item.id}`,
+                description: item.description,
+                completed: isCompletedStatus(item.status?.name || item.status_name || item.status),
+                priority: mapPriority(item.priority?.name || item.priority_name || item.priority),
+            });
+        }
+        return items;
+    },
+    async completeItem(config, externalId) {
+        const projectKey = config.project_key;
+        const workItemType = config.work_item_type;
+        await callMcpTool('meego', 'finish_node', {
+            project_key: projectKey,
+            work_item_type_key: workItemType,
+            work_item_id: Number(externalId),
+        });
+    },
+    async validateConfig(config) {
+        if (!config.project_key)
+            return 'project_key is required';
+        if (!config.work_item_type)
+            return 'work_item_type is required';
+        return null;
+    },
+};
+function isCompletedStatus(status) {
+    if (!status)
+        return false;
+    const lower = status.toLowerCase();
+    return lower === 'done' || lower === 'closed' || lower === 'completed' || lower === 'resolved';
+}
+function mapPriority(priority) {
+    if (!priority)
+        return 'medium';
+    if (typeof priority === 'number') {
+        if (priority >= 3)
+            return 'high';
+        if (priority >= 2)
+            return 'medium';
+        return 'low';
+    }
+    const lower = priority.toLowerCase();
+    if (lower.includes('high') || lower.includes('urgent') || lower.includes('critical'))
+        return 'high';
+    if (lower.includes('low') || lower.includes('minor'))
+        return 'low';
+    return 'medium';
+}

package/server/dist/server/src/services/providers/registry.js

@@ -0,0 +1,17 @@
+import { meegoProvider } from './meegoProvider.js';
+import { larkDocsProvider } from './larkDocsProvider.js';
+import { supabaseProvider } from './supabaseProvider.js';
+const providers = new Map();
+function register(p) {
+    providers.set(p.id, p);
+}
+// Register built-in providers
+register(meegoProvider);
+register(larkDocsProvider);
+register(supabaseProvider);
+export function getProvider(id) {
+    return providers.get(id);
+}
+export function getAllProviders() {
+    return Array.from(providers.values());
+}

package/server/dist/server/src/services/providers/supabaseProvider.js

@@ -0,0 +1,172 @@
+const configSchema = [
+    {
+        key: 'supabase_url',
+        label: 'Supabase Project URL',
+        type: 'string',
+        required: true,
+        placeholder: 'e.g. https://xxx.supabase.co',
+    },
+    {
+        key: 'anon_key',
+        label: 'API Key (anon/publishable)',
+        type: 'string',
+        required: true,
+        placeholder: 'eyJhbGciOiJIUzI1NiIs...',
+        secret: true,
+    },
+    {
+        key: 'table',
+        label: 'Table Name',
+        type: 'string',
+        required: true,
+        placeholder: 'e.g. bug_reports',
+    },
+    {
+        key: 'title_column',
+        label: 'Title Column',
+        type: 'string',
+        required: true,
+        placeholder: 'e.g. message',
+    },
+    {
+        key: 'status_column',
+        label: 'Status Column',
+        type: 'string',
+        required: false,
+        placeholder: 'e.g. status',
+    },
+    {
+        key: 'done_value',
+        label: 'Done Status Value',
+        type: 'string',
+        required: false,
+        placeholder: 'e.g. done',
+    },
+    {
+        key: 'description_columns',
+        label: 'Description Columns (comma-separated)',
+        type: 'string',
+        required: false,
+        placeholder: 'e.g. device_info,app_version,current_tab',
+    },
+    {
+        key: 'filter',
+        label: 'PostgREST Filter (optional)',
+        type: 'string',
+        required: false,
+        placeholder: 'e.g. status=eq.open or assigned_to=eq.me',
+    },
+];
+async function supabaseFetch(url, apiKey, path, options = {}) {
+    const res = await fetch(`${url}/rest/v1/${path}`, {
+        ...options,
+        headers: {
+            'apikey': apiKey,
+            'Authorization': `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+            'Prefer': options.method === 'PATCH' ? 'return=representation' : '',
+            ...options.headers,
+        },
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Supabase API error ${res.status}: ${body}`);
+    }
+    if (res.status === 204)
+        return null;
+    return res.json();
+}
+export const supabaseProvider = {
+    id: 'supabase',
+    displayName: 'Supabase',
+    configSchema,
+    async fetchItems(config) {
+        const url = config.supabase_url.replace(/\/$/, '');
+        const apiKey = config.anon_key;
+        const table = config.table;
+        const titleCol = config.title_column;
+        const statusCol = config.status_column;
+        const doneValue = config.done_value;
+        const descCols = config.description_columns;
+        const filter = config.filter;
+        // Build select columns
+        const selectCols = new Set(['id', titleCol, 'created_at']);
+        if (statusCol)
+            selectCols.add(statusCol);
+        if (descCols) {
+            descCols.split(',').map(c => c.trim()).filter(Boolean).forEach(c => selectCols.add(c));
+        }
+        let path = `${table}?select=${Array.from(selectCols).join(',')}&order=created_at.desc`;
+        if (filter) {
+            path += `&${filter}`;
+        }
+        const rows = await supabaseFetch(url, apiKey, path);
+        return rows.map(row => {
+            // Build description from extra columns
+            let description;
+            if (descCols) {
+                const parts = descCols.split(',').map(c => c.trim()).filter(Boolean);
+                const lines = [];
+                for (const col of parts) {
+                    const val = row[col];
+                    if (val == null || val === '' || (Array.isArray(val) && val.length === 0))
+                        continue;
+                    if (Array.isArray(val)) {
+                        lines.push(`${col}: ${val.join(', ')}`);
+                    }
+                    else {
+                        lines.push(`${col}: ${val}`);
+                    }
+                }
+                if (lines.length > 0)
+                    description = lines.join('\n');
+            }
+            const completed = statusCol && doneValue
+                ? String(row[statusCol]) === doneValue
+                : false;
+            return {
+                externalId: String(row.id),
+                externalUrl: `${url}/project/default/editor?table=${table}`,
+                title: String(row[titleCol] || `Row ${row.id}`),
+                description,
+                completed,
+                priority: mapStatusToPriority(statusCol ? row[statusCol] : undefined),
+            };
+        });
+    },
+    async completeItem(config, externalId) {
+        const url = config.supabase_url.replace(/\/$/, '');
+        const apiKey = config.anon_key;
+        const table = config.table;
+        const statusCol = config.status_column;
+        const doneValue = config.done_value;
+        if (!statusCol || !doneValue) {
+            throw new Error('Cannot complete: status_column and done_value not configured');
+        }
+        await supabaseFetch(url, apiKey, `${table}?id=eq.${externalId}`, {
+            method: 'PATCH',
+            body: JSON.stringify({ [statusCol]: doneValue }),
+        });
+    },
+    async validateConfig(config) {
+        if (!config.supabase_url)
+            return 'supabase_url is required';
+        if (!config.anon_key)
+            return 'anon_key is required';
+        if (!config.table)
+            return 'table is required';
+        if (!config.title_column)
+            return 'title_column is required';
+        return null;
+    },
+};
+function mapStatusToPriority(status) {
+    if (!status)
+        return 'medium';
+    const lower = String(status).toLowerCase();
+    if (lower === 'open')
+        return 'high';
+    if (lower === 'in_progress')
+        return 'medium';
+    return 'low';
+}