profclaw 0.0.1-beta.1

package/dist/labels/index.js

@@ -0,0 +1,248 @@
+/**
+ * Labels Service
+ *
+ * Manages labels for tickets with support for:
+ * - Project-scoped labels
+ * - Hierarchical labels (parent/child)
+ * - External sync tracking (GitHub, Linear)
+ */
+import { randomUUID } from 'crypto';
+import { eq, and, isNull, desc, asc } from 'drizzle-orm';
+import { getDb } from '../storage/index.js';
+import { labels, ticketLabels } from '../storage/schema.js';
+// LABEL CRUD
+/**
+ * Create a new label
+ */
+export async function createLabel(input) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    const id = randomUUID();
+    const now = new Date();
+    // Get max sort order for this project
+    const existing = await db
+        .select({ sortOrder: labels.sortOrder })
+        .from(labels)
+        .where(input.projectId ? eq(labels.projectId, input.projectId) : isNull(labels.projectId))
+        .orderBy(desc(labels.sortOrder))
+        .limit(1);
+    const sortOrder = (existing[0]?.sortOrder ?? 0) + 10000;
+    const newLabel = {
+        id,
+        projectId: input.projectId || null,
+        name: input.name,
+        description: input.description || null,
+        color: input.color || '#6B7280',
+        parentId: input.parentId || null,
+        sortOrder,
+        externalSource: input.externalSource || null,
+        externalId: input.externalId || null,
+        createdAt: now,
+        updatedAt: now,
+    };
+    await db.insert(labels).values(newLabel);
+    return newLabel;
+}
+/**
+ * Get a label by ID
+ */
+export async function getLabel(id) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    const result = await db.select().from(labels).where(eq(labels.id, id)).limit(1);
+    return result[0] || null;
+}
+/**
+ * List labels for a project (or workspace-level if no projectId)
+ */
+export async function listLabels(projectId) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    const result = await db
+        .select()
+        .from(labels)
+        .where(projectId ? eq(labels.projectId, projectId) : isNull(labels.projectId))
+        .orderBy(asc(labels.sortOrder), asc(labels.name));
+    return result;
+}
+/**
+ * Update a label
+ */
+export async function updateLabel(id, input) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    const updates = { updatedAt: new Date() };
+    if (input.name !== undefined)
+        updates.name = input.name;
+    if (input.description !== undefined)
+        updates.description = input.description;
+    if (input.color !== undefined)
+        updates.color = input.color;
+    if (input.parentId !== undefined)
+        updates.parentId = input.parentId;
+    if (input.sortOrder !== undefined)
+        updates.sortOrder = input.sortOrder;
+    await db.update(labels).set(updates).where(eq(labels.id, id));
+    const updated = await getLabel(id);
+    if (!updated)
+        throw new Error(`Label ${id} not found`);
+    return updated;
+}
+/**
+ * Delete a label
+ */
+export async function deleteLabel(id) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    // Delete ticket-label associations first
+    await db.delete(ticketLabels).where(eq(ticketLabels.labelId, id));
+    // Delete the label
+    await db.delete(labels).where(eq(labels.id, id));
+}
+// TICKET-LABEL ASSOCIATIONS
+/**
+ * Add a label to a ticket
+ */
+export async function addLabelToTicket(ticketId, labelId) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    // Check if already exists
+    const existing = await db
+        .select()
+        .from(ticketLabels)
+        .where(and(eq(ticketLabels.ticketId, ticketId), eq(ticketLabels.labelId, labelId)))
+        .limit(1);
+    if (existing.length > 0)
+        return; // Already exists
+    await db.insert(ticketLabels).values({
+        id: randomUUID(),
+        ticketId,
+        labelId,
+        addedAt: new Date(),
+    });
+}
+/**
+ * Remove a label from a ticket
+ */
+export async function removeLabelFromTicket(ticketId, labelId) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    await db
+        .delete(ticketLabels)
+        .where(and(eq(ticketLabels.ticketId, ticketId), eq(ticketLabels.labelId, labelId)));
+}
+/**
+ * Get all labels for a ticket
+ */
+export async function getTicketLabels(ticketId) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    const result = await db
+        .select({
+        id: labels.id,
+        projectId: labels.projectId,
+        name: labels.name,
+        description: labels.description,
+        color: labels.color,
+        parentId: labels.parentId,
+        sortOrder: labels.sortOrder,
+        externalSource: labels.externalSource,
+        externalId: labels.externalId,
+        createdAt: labels.createdAt,
+        updatedAt: labels.updatedAt,
+    })
+        .from(ticketLabels)
+        .innerJoin(labels, eq(ticketLabels.labelId, labels.id))
+        .where(eq(ticketLabels.ticketId, ticketId))
+        .orderBy(asc(labels.sortOrder));
+    return result;
+}
+/**
+ * Set all labels for a ticket (replaces existing)
+ */
+export async function setTicketLabels(ticketId, labelIds) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    // Remove all existing labels
+    await db.delete(ticketLabels).where(eq(ticketLabels.ticketId, ticketId));
+    // Add new labels
+    if (labelIds.length > 0) {
+        const now = new Date();
+        await db.insert(ticketLabels).values(labelIds.map((labelId) => ({
+            id: randomUUID(),
+            ticketId,
+            labelId,
+            addedAt: now,
+        })));
+    }
+}
+// EXTERNAL SYNC HELPERS
+/**
+ * Find a label by external source and ID
+ */
+export async function findLabelByExternalId(projectId, externalSource, externalId) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    const result = await db
+        .select()
+        .from(labels)
+        .where(and(eq(labels.projectId, projectId), eq(labels.externalSource, externalSource), eq(labels.externalId, externalId)))
+        .limit(1);
+    return result[0] || null;
+}
+/**
+ * Find or create a label from external source
+ */
+export async function findOrCreateLabel(projectId, name, options = {}) {
+    const db = getDb();
+    if (!db)
+        throw new Error('Database not initialized');
+    // Try to find by external ID first
+    if (options.externalSource && options.externalId) {
+        const byExternal = await findLabelByExternalId(projectId, options.externalSource, options.externalId);
+        if (byExternal)
+            return byExternal;
+    }
+    // Try to find by name
+    const byName = await db
+        .select()
+        .from(labels)
+        .where(and(eq(labels.projectId, projectId), eq(labels.name, name)))
+        .limit(1);
+    if (byName[0])
+        return byName[0];
+    // Create new label
+    return createLabel({
+        projectId,
+        name,
+        color: options.color,
+        externalSource: options.externalSource,
+        externalId: options.externalId,
+    });
+}
+/**
+ * Sync labels from GitHub issue labels
+ */
+export async function syncLabelsFromGitHub(projectId, githubLabels) {
+    const synced = [];
+    for (const ghLabel of githubLabels) {
+        const label = await findOrCreateLabel(projectId, ghLabel.name, {
+            color: ghLabel.color ? `#${ghLabel.color}` : undefined,
+            externalSource: 'github',
+            externalId: ghLabel.name, // GitHub uses name as ID
+        });
+        synced.push(label);
+    }
+    return synced;
+}
+//# sourceMappingURL=index.js.map

package/dist/mcp/browser-tools.d.ts

@@ -0,0 +1,10 @@
+/**
+ * MCP Browser Tools
+ *
+ * Browser automation tools for the profClaw MCP server.
+ * Uses centralized definitions from src/browser/tools.ts
+ */
+export declare const BROWSER_TOOLS: import("../tools/types.js").MCPToolSchema[];
+export declare const handleBrowserTool: (name: string, args: unknown) => Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult | null>;
+export declare function isBrowserTool(name: string): boolean;
+//# sourceMappingURL=browser-tools.d.ts.map

package/dist/mcp/browser-tools.js

@@ -0,0 +1,16 @@
+/**
+ * MCP Browser Tools
+ *
+ * Browser automation tools for the profClaw MCP server.
+ * Uses centralized definitions from src/browser/tools.ts
+ */
+import { MCP_BROWSER_TOOLS, handleMCPBrowserTool } from '../browser/index.js';
+// Re-export MCP tool definitions for server registration
+export const BROWSER_TOOLS = MCP_BROWSER_TOOLS;
+// Re-export handler for tool execution
+export const handleBrowserTool = handleMCPBrowserTool;
+// Type guard to check if a tool name is a browser tool
+export function isBrowserTool(name) {
+    return name.startsWith('profclaw__browser_');
+}
+//# sourceMappingURL=browser-tools.js.map

package/dist/mcp/client.d.ts

@@ -0,0 +1,54 @@
+export interface MCPServerConfig {
+    name: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    enabled?: boolean;
+}
+export interface MCPTool {
+    serverName: string;
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface MCPClientStatus {
+    name: string;
+    connected: boolean;
+    transport: 'stdio' | 'sse';
+    toolCount: number;
+    error?: string;
+}
+export declare class MCPClientManager {
+    private servers;
+    /**
+     * Connect to an MCP server using stdio or SSE transport.
+     */
+    connect(config: MCPServerConfig): Promise<void>;
+    /**
+     * Disconnect from a named MCP server and clean up its resources.
+     */
+    disconnect(name: string): Promise<void>;
+    /**
+     * Disconnect from all connected MCP servers.
+     */
+    disconnectAll(): Promise<void>;
+    /**
+     * Return a flat list of all tools from all connected servers.
+     */
+    listTools(): MCPTool[];
+    /**
+     * Execute a tool on a specific MCP server.
+     */
+    callTool(serverName: string, toolName: string, args: unknown): Promise<unknown>;
+    /**
+     * Return the connection status of every known server.
+     */
+    getStatus(): MCPClientStatus[];
+    /**
+     * Return a list of currently connected server names.
+     */
+    getConnectedServers(): string[];
+}
+export declare const mcpClientManager: MCPClientManager;
+//# sourceMappingURL=client.d.ts.map

package/dist/mcp/client.js

@@ -0,0 +1,153 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { logger } from '../utils/logger.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function extractToolSchema(raw) {
+    if (isRecord(raw))
+        return raw;
+    return {};
+}
+export class MCPClientManager {
+    servers = new Map();
+    /**
+     * Connect to an MCP server using stdio or SSE transport.
+     */
+    async connect(config) {
+        const { name, enabled = true } = config;
+        if (!enabled) {
+            logger.info(`[MCP] Skipping disabled server: ${name}`);
+            return;
+        }
+        if (this.servers.has(name)) {
+            logger.warn(`[MCP] Server already connected: ${name}. Disconnecting first.`);
+            await this.disconnect(name);
+        }
+        if (!config.command && !config.url) {
+            throw new Error(`[MCP] Server config for "${name}" must have either 'command' or 'url'.`);
+        }
+        const transportType = config.url ? 'sse' : 'stdio';
+        logger.info(`[MCP] Connecting to server: ${name} (${transportType})`);
+        try {
+            let transport;
+            if (transportType === 'stdio') {
+                transport = new StdioClientTransport({
+                    command: config.command,
+                    args: config.args ?? [],
+                    env: config.env,
+                });
+            }
+            else {
+                transport = new SSEClientTransport(new URL(config.url));
+            }
+            const client = new Client({ name: 'profclaw-mcp-client', version: '1.0.0' }, { capabilities: {} });
+            await client.connect(transport);
+            const toolsResponse = await client.listTools();
+            const tools = (toolsResponse.tools ?? []).map((t) => ({
+                serverName: name,
+                name: t.name,
+                description: t.description,
+                inputSchema: extractToolSchema(t.inputSchema),
+            }));
+            this.servers.set(name, { client, config, tools, transport: transportType });
+            logger.info(`[MCP] Connected to "${name}" - ${tools.length} tool(s) available`, {
+                server: name,
+                toolCount: tools.length,
+                tools: tools.map((t) => t.name),
+            });
+        }
+        catch (error) {
+            logger.error(`[MCP] Failed to connect to server: ${name}`, error instanceof Error ? error : undefined, { server: name });
+            throw error;
+        }
+    }
+    /**
+     * Disconnect from a named MCP server and clean up its resources.
+     */
+    async disconnect(name) {
+        const server = this.servers.get(name);
+        if (!server) {
+            logger.warn(`[MCP] disconnect called for unknown server: ${name}`);
+            return;
+        }
+        try {
+            await server.client.close();
+            logger.info(`[MCP] Disconnected from server: ${name}`);
+        }
+        catch (error) {
+            logger.error(`[MCP] Error while disconnecting from server: ${name}`, error instanceof Error ? error : undefined, { server: name });
+        }
+        finally {
+            this.servers.delete(name);
+        }
+    }
+    /**
+     * Disconnect from all connected MCP servers.
+     */
+    async disconnectAll() {
+        const names = Array.from(this.servers.keys());
+        logger.info(`[MCP] Disconnecting from all servers (${names.length})`);
+        await Promise.allSettled(names.map((name) => this.disconnect(name)));
+    }
+    /**
+     * Return a flat list of all tools from all connected servers.
+     */
+    listTools() {
+        const all = [];
+        for (const server of this.servers.values()) {
+            all.push(...server.tools);
+        }
+        return all;
+    }
+    /**
+     * Execute a tool on a specific MCP server.
+     */
+    async callTool(serverName, toolName, args) {
+        const server = this.servers.get(serverName);
+        if (!server) {
+            throw new Error(`[MCP] No connected server named "${serverName}".`);
+        }
+        const toolExists = server.tools.some((t) => t.name === toolName);
+        if (!toolExists) {
+            throw new Error(`[MCP] Tool "${toolName}" not found on server "${serverName}".`);
+        }
+        logger.debug(`[MCP] Calling tool "${toolName}" on server "${serverName}"`, {
+            server: serverName,
+            tool: toolName,
+        });
+        try {
+            const safeArgs = isRecord(args) ? args : {};
+            const result = await server.client.callTool({ name: toolName, arguments: safeArgs });
+            logger.debug(`[MCP] Tool "${toolName}" on "${serverName}" completed`, {
+                server: serverName,
+                tool: toolName,
+            });
+            return result;
+        }
+        catch (error) {
+            logger.error(`[MCP] Tool call failed: "${toolName}" on "${serverName}"`, error instanceof Error ? error : undefined, { server: serverName, tool: toolName });
+            throw error;
+        }
+    }
+    /**
+     * Return the connection status of every known server.
+     */
+    getStatus() {
+        return Array.from(this.servers.entries()).map(([name, server]) => ({
+            name,
+            connected: true,
+            transport: server.transport,
+            toolCount: server.tools.length,
+        }));
+    }
+    /**
+     * Return a list of currently connected server names.
+     */
+    getConnectedServers() {
+        return Array.from(this.servers.keys());
+    }
+}
+export const mcpClientManager = new MCPClientManager();
+//# sourceMappingURL=client.js.map

package/dist/mcp/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * MCP Module
+ *
+ * Model Context Protocol server for Claude Code integration.
+ * Run as a separate process, not imported into the main server.
+ *
+ * Usage:
+ *   npx @profclaw/profclaw-mcp
+ *   node dist/mcp/server.js
+ */
+export * from './server.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/index.js

@@ -0,0 +1,13 @@
+/**
+ * MCP Module
+ *
+ * Model Context Protocol server for Claude Code integration.
+ * Run as a separate process, not imported into the main server.
+ *
+ * Usage:
+ *   npx @profclaw/profclaw-mcp
+ *   node dist/mcp/server.js
+ */
+// Re-export for programmatic usage if needed
+export * from './server.js';
+//# sourceMappingURL=index.js.map

package/dist/mcp/server.d.ts

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+/**
+ * profClaw MCP Server
+ *
+ * Model Context Protocol server for Claude Code integration.
+ * Allows Claude Code to report task progress to profClaw with minimal token usage.
+ *
+ * Usage:
+ *   npx @profclaw/task-manager-mcp
+ *   OR
+ *   node dist/mcp/server.js
+ *
+ * Claude Code settings.json:
+ * {
+ *   "mcpServers": {
+ *     "profclaw": {
+ *       "command": "npx",
+ *       "args": ["@profclaw/task-manager-mcp"]
+ *     }
+ *   }
+ * }
+ */
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+interface LogTaskArgs {
+    taskId?: string;
+    title: string;
+    summary: string;
+    filesChanged?: string[];
+}
+interface CompleteTaskArgs {
+    taskId?: string;
+    summary: string;
+    prUrl?: string;
+    filesChanged?: string[];
+}
+export declare function handleLogTask(args: LogTaskArgs): Promise<CallToolResult>;
+export declare function handleCompleteTask(args: CompleteTaskArgs): Promise<CallToolResult>;
+export declare function calculateCost(input: number, output: number, model: string): number;
+export {};
+//# sourceMappingURL=server.d.ts.map