trapic-mcp 0.1.0

package/dist/ollama.js

@@ -0,0 +1,63 @@
+/**
+ * LLM chat completion — supports Ollama (local) and OpenAI (cloud)
+ * Set OPENAI_API_KEY to use OpenAI, otherwise falls back to Ollama
+ */
+function getOllamaUrl() {
+    return process.env.OLLAMA_URL ?? "http://localhost:11434";
+}
+function getOllamaChatModel() {
+    return process.env.OLLAMA_CHAT_MODEL ?? "qwen3:8b";
+}
+function getOpenAIKey() {
+    return process.env.OPENAI_API_KEY;
+}
+function getOpenAIChatModel() {
+    return process.env.OPENAI_CHAT_MODEL ?? "gpt-4o-mini";
+}
+async function ollamaChatImpl(messages) {
+    const model = getOllamaChatModel();
+    const response = await fetch(`${getOllamaUrl()}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            model,
+            messages,
+            stream: false,
+            format: "json",
+            options: { temperature: 0.2 },
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Ollama chat failed (${response.status}): ${await response.text()}. ` +
+            `請確認 Ollama 正在運行且已安裝 ${model} 模型。`);
+    }
+    const data = await response.json();
+    return data.message.content;
+}
+async function openaiChatImpl(messages) {
+    const response = await fetch("https://api.openai.com/v1/chat/completions", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${getOpenAIKey()}`,
+        },
+        body: JSON.stringify({
+            model: getOpenAIChatModel(),
+            messages,
+            temperature: 0.2,
+            response_format: { type: "json_object" },
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`OpenAI chat failed (${response.status}): ${await response.text()}`);
+    }
+    const data = await response.json();
+    return data.choices[0].message.content;
+}
+export async function ollamaChat(messages) {
+    if (getOpenAIKey()) {
+        return openaiChatImpl(messages);
+    }
+    return ollamaChatImpl(messages);
+}
+//# sourceMappingURL=ollama.js.map

package/dist/quota.d.ts

@@ -0,0 +1,7 @@
+export interface QuotaCheck {
+    allowed: boolean;
+    used: number;
+    limit: number;
+    remaining: number;
+}
+export declare function checkMonthlyQuota(userId: string): Promise<QuotaCheck>;

package/dist/quota.js

@@ -0,0 +1,16 @@
+import { getSupabase } from "./supabase.js";
+import { getUserLimits } from "./config.js";
+export async function checkMonthlyQuota(userId) {
+    const supabase = getSupabase();
+    const limits = getUserLimits(userId);
+    const { data } = await supabase.rpc("get_monthly_trace_count", {
+        p_user_id: userId,
+    });
+    const used = typeof data === "number" ? data : 0;
+    return {
+        allowed: used < limits.traces,
+        used,
+        limit: limits.traces,
+        remaining: Math.max(0, limits.traces - used),
+    };
+}

package/dist/rate-limit.d.ts

@@ -0,0 +1,5 @@
+export declare function isRateLimited(userId: string): {
+    limited: boolean;
+    count: number;
+};
+export declare function recordRequest(userId: string): void;

package/dist/rate-limit.js

@@ -0,0 +1,38 @@
+import { getUserLimits } from "./config.js";
+const windows = new Map();
+const WINDOW_MS = 60_000;
+const CLEANUP_INTERVAL = 5 * 60_000;
+let lastCleanup = Date.now();
+function getWindow(userId, now) {
+    const ts = (windows.get(userId) || []).filter(t => now - t < WINDOW_MS);
+    if (ts.length === 0) {
+        windows.delete(userId);
+    }
+    else {
+        windows.set(userId, ts);
+    }
+    return ts;
+}
+function maybeCleanup(now) {
+    if (now - lastCleanup < CLEANUP_INTERVAL)
+        return;
+    lastCleanup = now;
+    for (const [userId, ts] of windows) {
+        if (ts.every(t => now - t >= WINDOW_MS)) {
+            windows.delete(userId);
+        }
+    }
+}
+export function isRateLimited(userId) {
+    const now = Date.now();
+    maybeCleanup(now);
+    const ts = getWindow(userId, now);
+    const maxReq = getUserLimits(userId).rateLimit;
+    return { limited: ts.length >= maxReq, count: ts.length };
+}
+export function recordRequest(userId) {
+    const now = Date.now();
+    const ts = getWindow(userId, now);
+    ts.push(now);
+    windows.set(userId, ts);
+}

package/dist/request-context.d.ts

@@ -0,0 +1,3 @@
+export declare function setCurrentUserId(id: string | null): void;
+export declare function getCurrentUserId(): string | null;
+//# sourceMappingURL=request-context.d.ts.map

package/dist/request-context.js

@@ -0,0 +1,12 @@
+/**
+ * Request-scoped user context
+ * CF Workers are single-threaded per request, so a simple global is safe
+ */
+let _currentUserId = null;
+export function setCurrentUserId(id) {
+    _currentUserId = id;
+}
+export function getCurrentUserId() {
+    return _currentUserId;
+}
+//# sourceMappingURL=request-context.js.map

package/dist/supabase.d.ts

@@ -0,0 +1,2 @@
+import { SupabaseClient } from "@supabase/supabase-js";
+export declare function getSupabase(): SupabaseClient;

package/dist/supabase.js

@@ -0,0 +1,16 @@
+import { createClient } from "@supabase/supabase-js";
+let client = null;
+export function getSupabase() {
+    if (client)
+        return client;
+    const url = process.env.SUPABASE_URL;
+    const key = process.env.SUPABASE_SERVICE_ROLE_KEY;
+    if (!url || !key) {
+        throw new Error("Missing SUPABASE_URL or SUPABASE_SERVICE_ROLE_KEY environment variables. " +
+            "請設定 Supabase 連線資訊。");
+    }
+    client = createClient(url, key, {
+        auth: { persistSession: false, autoRefreshToken: false },
+    });
+    return client;
+}

package/dist/team-access.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Team access helper — resolves which user IDs a user can see traces from.
+ * Returns the user's own ID + all team members' IDs (for team knowledge access).
+ */
+export declare function getVisibleAuthors(userId: string): Promise<Set<string>>;

package/dist/team-access.js

@@ -0,0 +1,35 @@
+/**
+ * Team access helper — resolves which user IDs a user can see traces from.
+ * Returns the user's own ID + all team members' IDs (for team knowledge access).
+ */
+import { getSupabase } from "./supabase.js";
+const cache = new Map();
+const CACHE_TTL = 60_000; // 1 minute
+export async function getVisibleAuthors(userId) {
+    const now = Date.now();
+    const cached = cache.get(userId);
+    if (cached && now - cached.ts < CACHE_TTL)
+        return cached.ids;
+    const ids = new Set([userId]);
+    const supabase = getSupabase();
+    // Find all teams user is in
+    const { data: myTeams } = await supabase
+        .from("team_members")
+        .select("team_id")
+        .eq("user_id", userId);
+    if (myTeams && myTeams.length > 0) {
+        const teamIds = myTeams.map((t) => t.team_id);
+        // Get all members of those teams
+        const { data: members } = await supabase
+            .from("team_members")
+            .select("user_id")
+            .in("team_id", teamIds);
+        if (members) {
+            for (const m of members) {
+                ids.add(m.user_id);
+            }
+        }
+    }
+    cache.set(userId, { ids, ts: now });
+    return ids;
+}

package/dist/tools/active.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerActive(server: McpServer, userId: string | null): void;

package/dist/tools/active.js

@@ -0,0 +1,63 @@
+import { z } from "zod";
+import { getSupabase } from "../supabase.js";
+import { getVisibleAuthors } from "../team-access.js";
+export function registerActive(server, userId) {
+    server.tool("trapic_get_active", "Get all active traces, optionally filtered by tags. Returns the current organizational knowledge base. " +
+        "取得所有 active 狀態的 trace，可按標籤過濾。返回目前的組織知識庫。", {
+        tags: z.array(z.string()).optional().describe("Filter by tags (returns traces matching ANY of these tags). Leave empty for all active traces. " +
+            "按標籤過濾（符合任一標籤即返回）。留空則返回所有 active traces"),
+        limit: z.number().int().min(1).max(200).default(50).describe("Maximum number of results (1-200, default: 50). " +
+            "最多返回筆數（1-200，預設 50）"),
+    }, async (params) => {
+        try {
+            const supabase = getSupabase();
+            const { data, error } = await supabase.rpc("get_active_traces", {
+                filter_tags: params.tags ?? [],
+                result_limit: params.limit,
+            });
+            if (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error getting active traces: ${error.message}\n取得 active traces 失敗：${error.message}`,
+                        },
+                    ],
+                };
+            }
+            // Post-filter: show own traces + team members' traces
+            const visibleAuthors = userId ? await getVisibleAuthors(userId) : null;
+            const filtered = visibleAuthors
+                ? (data ?? []).filter((row) => visibleAuthors.has(row.author))
+                : (data ?? []);
+            const traces = filtered.map((row) => ({
+                id: row.id,
+                claim: row.claim,
+                reason: row.reason,
+                tags: row.tags,
+                caused_by: row.caused_by,
+                confidence: row.confidence,
+                author: row.author,
+                created_at: row.created_at,
+            }));
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            total: traces.length,
+                            filter_tags: params.tags ?? [],
+                            traces,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+            };
+        }
+    });
+}

package/dist/tools/assert.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerAssert(server: McpServer): void;
+//# sourceMappingURL=assert.d.ts.map

package/dist/tools/assert.js

@@ -0,0 +1,141 @@
+import { z } from "zod";
+import { getSupabase } from "../supabase.js";
+export function registerAssert(server) {
+    // trace.assert — 對一個 trace 表態
+    server.tool("trace.assert", "Assert a position on an existing trace — agree, disagree, amend, flag as outdated, or confirm. " +
+        "Different people can assert different positions on the same trace, building organizational consensus. " +
+        "對一個 trace 表態 — 同意、不同意、補充、標記過時或驗證確認。" +
+        "不同人可以對同一個 trace 表達不同立場，形成組織共識。", {
+        trace_id: z.string().uuid().describe("ID of the trace to assert on. " +
+            "要表態的 trace ID"),
+        author: z.string().uuid().describe("User ID of the person making the assertion. " +
+            "表態者的 user ID"),
+        type: z.enum(["agree", "disagree", "amend", "outdated", "confirm"]).describe("Type of assertion: " +
+            "agree (I support this), " +
+            "disagree (I have a different view), " +
+            "amend (I want to add a perspective), " +
+            "outdated (this is no longer valid), " +
+            "confirm (I verified this is correct). " +
+            "表態類型：agree 同意 / disagree 不同意 / amend 補充 / outdated 已過時 / confirm 驗證確認"),
+        comment: z.string().optional().describe("Why you hold this position. Required for disagree/amend/outdated, optional for agree/confirm. " +
+            "為什麼持此立場。disagree/amend/outdated 必須說明，agree/confirm 可省略。"),
+        linked_trace_id: z.string().uuid().optional().describe("For 'amend' type: link to a new trace that extends this one. " +
+            "amend 時可連結到補充用的新 trace"),
+    }, async (params) => {
+        try {
+            // Validate: disagree/amend/outdated should have a comment
+            if (["disagree", "amend", "outdated"].includes(params.type) &&
+                !params.comment?.trim()) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `A comment is required for '${params.type}' assertions. Please explain your position.\n` +
+                                `'${params.type}' 類型的表態需要提供理由。`,
+                        },
+                    ],
+                };
+            }
+            const supabase = getSupabase();
+            const record = {
+                trace_id: params.trace_id,
+                author: params.author,
+                type: params.type,
+                comment: params.comment ?? null,
+                linked_trace_id: params.linked_trace_id ?? null,
+            };
+            const { data, error } = await supabase
+                .from("trace_assertions")
+                .insert(record)
+                .select()
+                .single();
+            if (error) {
+                // Handle unique constraint violation
+                if (error.code === "23505") {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `You already have a '${params.type}' assertion on this trace. Each person can only assert each type once per trace.\n` +
+                                    `你已經對此 trace 有 '${params.type}' 表態了。每人每種類型只能表態一次。`,
+                            },
+                        ],
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error creating assertion: ${error.message}\n建立表態失敗：${error.message}`,
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            message: "Assertion recorded / 表態已記錄",
+                            assertion: {
+                                id: data.id,
+                                trace_id: data.trace_id,
+                                type: data.type,
+                                comment: data.comment,
+                                linked_trace_id: data.linked_trace_id,
+                                created_at: data.created_at,
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+            };
+        }
+    });
+    // trace.consensus — 取得某個 trace 的共識摘要
+    server.tool("trace.consensus", "Get the consensus summary for a trace — how many people agree, disagree, amend, etc. " +
+        "Shows the collective organizational position on a knowledge proposition. " +
+        "取得某個 trace 的共識摘要 — 多少人同意、不同意、補充等。" +
+        "呈現組織對一個知識命題的集體立場。", {
+        trace_id: z.string().uuid().describe("ID of the trace to get consensus for. " +
+            "要查看共識的 trace ID"),
+    }, async (params) => {
+        try {
+            const supabase = getSupabase();
+            const { data, error } = await supabase.rpc("get_trace_consensus", {
+                target_trace_id: params.trace_id,
+            });
+            if (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error getting consensus: ${error.message}\n取得共識摘要失敗：${error.message}`,
+                        },
+                    ],
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(data, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+            };
+        }
+    });
+}
+//# sourceMappingURL=assert.js.map

package/dist/tools/chain.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerChain(server: McpServer, userId: string | null): void;

package/dist/tools/chain.js

@@ -0,0 +1,118 @@
+import { z } from "zod";
+import { getSupabase } from "../supabase.js";
+export function registerChain(server, userId) {
+    // trace.get_chain — traverse upstream causal chain
+    server.tool("trapic_get_chain", "Get the causal chain of a trace — recursively follows caused_by links upstream to find root causes. " +
+        "取得 trace 的因果鏈 — 遞迴追溯 caused_by 上游，找到根本原因。", {
+        trace_id: z.string().uuid().describe("ID of the trace to start from. " +
+            "起始 trace 的 ID"),
+        max_depth: z.number().int().min(1).max(20).default(5).describe("Maximum recursion depth (1-20, default: 5). " +
+            "最大遞迴深度（1-20，預設 5）"),
+    }, async (params) => {
+        try {
+            const supabase = getSupabase();
+            const { data, error } = await supabase.rpc("get_trace_chain", {
+                trace_id: params.trace_id,
+                max_depth: params.max_depth,
+            });
+            if (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error getting trace chain: ${error.message}\n取得因果鏈失敗：${error.message}`,
+                        },
+                    ],
+                };
+            }
+            // Post-filter by author for user isolation
+            const filtered = userId
+                ? (data ?? []).filter((row) => row.author === userId)
+                : (data ?? []);
+            const chain = filtered.map((row) => ({
+                id: row.id,
+                claim: row.claim,
+                reason: row.reason,
+                status: row.status,
+                tags: row.tags,
+                caused_by: row.caused_by,
+                depth: row.depth,
+            }));
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            trace_id: params.trace_id,
+                            chain_length: chain.length,
+                            chain,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+            };
+        }
+    });
+    // trace.get_effects — traverse downstream effects
+    server.tool("trapic_get_effects", "Get downstream effects of a trace — finds all traces whose caused_by includes this trace, recursively. " +
+        "取得 trace 的下游影響 — 遞迴查找所有 caused_by 包含此 trace 的後續 trace。", {
+        trace_id: z.string().uuid().describe("ID of the trace to find effects for. " +
+            "要查找影響的 trace ID"),
+        max_depth: z.number().int().min(1).max(20).default(5).describe("Maximum recursion depth (1-20, default: 5). " +
+            "最大遞迴深度（1-20，預設 5）"),
+    }, async (params) => {
+        try {
+            const supabase = getSupabase();
+            const { data, error } = await supabase.rpc("get_trace_effects", {
+                trace_id: params.trace_id,
+                max_depth: params.max_depth,
+            });
+            if (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error getting trace effects: ${error.message}\n取得下游影響失敗：${error.message}`,
+                        },
+                    ],
+                };
+            }
+            // Post-filter by author for user isolation
+            const filteredEffects = userId
+                ? (data ?? []).filter((row) => row.author === userId)
+                : (data ?? []);
+            const effects = filteredEffects.map((row) => ({
+                id: row.id,
+                claim: row.claim,
+                reason: row.reason,
+                status: row.status,
+                tags: row.tags,
+                caused_by: row.caused_by,
+                depth: row.depth,
+            }));
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            trace_id: params.trace_id,
+                            effects_count: effects.length,
+                            effects,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+            };
+        }
+    });
+}

package/dist/tools/context.d.ts

@@ -0,0 +1,7 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function contextualizeTrace(traceId: string): Promise<{
+    success: boolean;
+    actions: string[];
+    error?: string;
+}>;
+export declare function registerContext(server: McpServer, userId: string | null): void;