trapic-mcp 0.1.0

package/dist/tools/search.js

@@ -0,0 +1,92 @@
+import { z } from "zod";
+import { getSupabase } from "../supabase.js";
+import { generateEmbedding } from "../embedding.js";
+import { audit } from "../audit.js";
+import { getVisibleAuthors } from "../team-access.js";
+export function registerSearch(server, userId) {
+    server.tool("trapic_search", "Semantic search for traces using natural language query. Combines vector similarity with optional tag/scope filtering. " +
+        "使用自然語言進行語意搜尋，結合向量相似度與標籤/範圍過濾。", {
+        query: z.string().describe("Natural language search query. " +
+            "自然語言搜尋查詢"),
+        tags: z.array(z.string()).optional().describe("Filter by tags (returns traces matching ANY of these tags). " +
+            "按標籤過濾（符合任一標籤即返回）"),
+        scope: z.enum(["personal", "team", "org"]).optional().describe("Filter by visibility scope. " +
+            "按可見範圍過濾"),
+        status: z.enum(["active", "superseded", "deprecated"]).default("active").describe("Filter by status (default: active). " +
+            "按狀態過濾（預設：active）"),
+        limit: z.number().int().min(1).max(50).default(10).describe("Maximum number of results (1-50, default: 10). " +
+            "最多返回筆數（1-50，預設 10）"),
+        threshold: z.number().min(0).max(1).default(0.7).describe("Minimum similarity threshold (0-1, default: 0.7). " +
+            "最低相似度閾值（0-1，預設 0.7）"),
+    }, async (params) => {
+        try {
+            const supabase = getSupabase();
+            // Generate query embedding
+            const queryEmbedding = await generateEmbedding(params.query);
+            // Call the search_traces RPC
+            const { data, error } = await supabase.rpc("search_traces", {
+                query_embedding: queryEmbedding,
+                filter_tags: params.tags ?? [],
+                filter_scope: params.scope ?? null,
+                filter_status: params.status,
+                match_limit: params.limit,
+                match_threshold: params.threshold,
+            });
+            if (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error searching traces: ${error.message}\n搜尋 Trace 失敗：${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 results = filtered.map((row) => ({
+                id: row.id,
+                claim: row.claim,
+                reason: row.reason,
+                status: row.status,
+                tags: row.tags,
+                caused_by: row.caused_by,
+                confidence: row.confidence,
+                source: row.source,
+                author: row.author,
+                created_at: row.created_at,
+                similarity: typeof row.similarity === "number"
+                    ? Math.round(row.similarity * 1000) / 1000
+                    : row.similarity,
+            }));
+            if (userId)
+                audit(userId, "trace.search", "trace", undefined, { query: params.query, results: results.length });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            query: params.query,
+                            result_count: results.length,
+                            results,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: ${message}`,
+                    },
+                ],
+            };
+        }
+    });
+}

package/dist/tools/summary.d.ts

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

package/dist/tools/summary.js

@@ -0,0 +1,176 @@
+import { z } from "zod";
+import { getSupabase } from "../supabase.js";
+import { generateEmbeddings } from "../embedding.js";
+import { contextualizeTrace } from "./context.js";
+import { llmChat } from "../llm.js";
+import { checkMonthlyQuota } from "../quota.js";
+const SUMMARY_EXTRACTION_PROMPT = `You are a knowledge extraction engine. Given a conversation summary, extract all key decisions, discoveries, and conclusions as Traces.
+
+A Trace is a minimal causal proposition — one clear statement (claim) with an optional reason (why).
+
+## What to extract
+
+1. **Decisions** — what was decided and why
+2. **Discoveries** — what was learned or realized
+3. **Conclusions** — what was concluded from the discussion
+
+## Rules
+
+- Each trace = ONE proposition. Do not combine multiple ideas.
+- claim = what happened / what was concluded (one clear sentence)
+- reason = why (optional — some facts have no reason)
+- Auto-assign tags based on content (e.g., "architecture", "design", "api", "performance", "security", "ux", "database", "deployment", "process", "decision")
+- Be thorough but avoid extracting trivial or obvious statements
+
+## Output format
+
+Return JSON: { "traces": [{ "claim": "...", "reason": "..." or null, "tags": ["..."] }] }`;
+export function registerSummary(server, userId) {
+    server.tool("trapic_auto_summary", "Extract and create multiple traces from a conversation summary in one call. " +
+        "Uses LLM to identify key decisions, discoveries, and conclusions, then writes them all to DB. " +
+        "從對話摘要中批次提取並建立多條 trace。", {
+        text: z.string().describe("Conversation summary text to extract traces from. 要提取 trace 的對話摘要文字"),
+        tags: z.array(z.string()).default([]).describe("Additional tags to apply to all created traces. 額外標籤（套用到所有建立的 trace）"),
+        source_id: z.string().optional().describe("Source reference ID (e.g. session ID). 來源參考 ID"),
+    }, async (params) => {
+        try {
+            if (!userId) {
+                return {
+                    content: [{ type: "text", text: "Error: Authentication required." }],
+                };
+            }
+            const effectiveUserId = userId;
+            // Check monthly quota before doing LLM work
+            const quota = await checkMonthlyQuota(effectiveUserId);
+            if (!quota.allowed) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Monthly trace limit reached (${quota.used}/${quota.limit}). Resets next month.`,
+                        }],
+                };
+            }
+            // 1. Use LLM to extract traces from summary
+            const content = await llmChat([
+                { role: "system", content: SUMMARY_EXTRACTION_PROMPT },
+                { role: "user", content: params.text },
+            ]);
+            let extracted;
+            try {
+                const parsed = JSON.parse(content);
+                const rawTraces = Array.isArray(parsed) ? parsed : (parsed.traces ?? parsed.results ?? []);
+                extracted = rawTraces
+                    .map((t) => ({
+                    claim: String(t.claim ?? ""),
+                    reason: t.reason ? String(t.reason) : null,
+                    tags: Array.isArray(t.tags) ? t.tags.map(String) : [],
+                }))
+                    .filter((t) => t.claim.trim().length > 0);
+            }
+            catch {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error parsing LLM response. Raw output:\n${content}\n\nLLM 回應解析失敗。`,
+                        }],
+                };
+            }
+            // Cap at 20 to prevent excessive insertions
+            extracted = extracted.slice(0, 20);
+            if (extracted.length === 0) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                message: "No traces extracted from summary. 摘要中未提取到任何 trace。",
+                                traces_created: 0,
+                            }, null, 2),
+                        }],
+                };
+            }
+            // 2. Truncate to remaining quota (use quota from initial check)
+            extracted = extracted.slice(0, Math.min(20, quota.remaining));
+            // 3. Batch generate embeddings, then create traces in DB
+            const supabase = getSupabase();
+            const created = [];
+            const errors = [];
+            // Batch embedding generation
+            const embeddingTexts = extracted.map((trace) => trace.reason ? `${trace.claim} ${trace.reason}` : trace.claim);
+            let embeddings;
+            try {
+                embeddings = await generateEmbeddings(embeddingTexts);
+            }
+            catch (embErr) {
+                const embMsg = embErr instanceof Error ? embErr.message : String(embErr);
+                return {
+                    content: [{ type: "text", text: `Error generating embeddings: ${embMsg}` }],
+                };
+            }
+            // Insert traces in batches of 5
+            const BATCH_SIZE = 5;
+            for (let i = 0; i < extracted.length; i += BATCH_SIZE) {
+                const batch = extracted.slice(i, i + BATCH_SIZE);
+                const batchEmbeddings = embeddings.slice(i, i + BATCH_SIZE);
+                const results = await Promise.allSettled(batch.map(async (trace, idx) => {
+                    // Merge user-provided tags with LLM-extracted tags
+                    const mergedTags = [...new Set([...params.tags, ...trace.tags])];
+                    // Insert into DB
+                    const { data, error } = await supabase
+                        .from("traces")
+                        .insert({
+                        claim: trace.claim,
+                        reason: trace.reason,
+                        scope: "personal",
+                        author: effectiveUserId,
+                        tags: mergedTags,
+                        caused_by: [],
+                        source: "extraction",
+                        source_id: params.source_id ?? null,
+                        confidence: "low",
+                        references: [],
+                        embedding: batchEmbeddings[idx],
+                    })
+                        .select()
+                        .single();
+                    if (error) {
+                        throw new Error(`Failed to create trace "${trace.claim}": ${error.message}`);
+                    }
+                    // Contextualize (non-blocking failure)
+                    await contextualizeTrace(data.id).catch(() => null);
+                    return {
+                        id: data.id,
+                        claim: data.claim,
+                        reason: data.reason,
+                        tags: data.tags,
+                    };
+                }));
+                for (const result of results) {
+                    if (result.status === "fulfilled") {
+                        created.push(result.value);
+                    }
+                    else {
+                        errors.push(result.reason?.message ?? String(result.reason));
+                    }
+                }
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            message: `Created ${created.length} trace(s) from summary. 從摘要建立了 ${created.length} 條 trace。`,
+                            traces_created: created.length,
+                            traces_extracted: extracted.length,
+                            traces: created,
+                            errors: errors.length > 0 ? errors : undefined,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+            };
+        }
+    });
+}

package/dist/tools/update.d.ts

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

package/dist/tools/update.js

@@ -0,0 +1,134 @@
+import { z } from "zod";
+import { getSupabase } from "../supabase.js";
+import { generateEmbedding } from "../embedding.js";
+import { audit } from "../audit.js";
+export function registerUpdate(server, userId) {
+    server.tool("trapic_update", "Update an existing trace — change status, tags, claim/reason, or mark as superseded. " +
+        "更新現有 trace — 可以變更狀態、標籤、claim/reason，或標記為被取代。", {
+        trace_id: z.string().uuid().describe("ID of the trace to update. " +
+            "要更新的 trace ID"),
+        claim: z.string().optional().describe("Updated claim text. Will regenerate embedding if changed. " +
+            "更新的 claim 文字。如果變更會重新產生 embedding"),
+        reason: z.string().optional().describe("Updated reason text. Will regenerate embedding if changed. " +
+            "更新的 reason 文字。如果變更會重新產生 embedding"),
+        status: z.enum(["active", "superseded", "deprecated"]).optional().describe("New status for the trace. " +
+            "trace 的新狀態"),
+        superseded_by: z.string().uuid().optional().describe("ID of the trace that supersedes this one (sets status to 'superseded' automatically). " +
+            "取代此 trace 的新 trace ID（會自動將狀態設為 superseded）"),
+        tags: z.array(z.string()).optional().describe("Replace tags with this new list. " +
+            "用新的標籤列表替換"),
+        confidence: z.enum(["high", "medium", "low"]).optional().describe("Updated confidence level. " +
+            "更新的信心程度"),
+        references: z.array(z.string()).optional().describe("Replace references with this new list. " +
+            "用新的參考連結列表替換"),
+    }, async (params) => {
+        try {
+            const supabase = getSupabase();
+            // Build update object with only provided fields
+            const update = {};
+            if (params.claim !== undefined)
+                update.claim = params.claim;
+            if (params.reason !== undefined)
+                update.reason = params.reason;
+            if (params.tags !== undefined)
+                update.tags = params.tags;
+            if (params.confidence !== undefined)
+                update.confidence = params.confidence;
+            if (params.references !== undefined)
+                update.references = params.references;
+            // Handle superseded_by — auto-set status
+            if (params.superseded_by !== undefined) {
+                update.superseded_by = params.superseded_by;
+                update.status = "superseded";
+            }
+            else if (params.status !== undefined) {
+                update.status = params.status;
+            }
+            // Regenerate embedding if claim or reason changed
+            if (params.claim !== undefined || params.reason !== undefined) {
+                // Fetch current trace to get existing claim/reason if only one changed
+                let query = supabase
+                    .from("traces")
+                    .select("claim, reason")
+                    .eq("id", params.trace_id);
+                if (userId)
+                    query = query.eq("author", userId);
+                const { data: current, error: fetchError } = await query.single();
+                if (fetchError) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Error fetching current trace: ${fetchError.message}\n取得現有 trace 失敗：${fetchError.message}`,
+                            },
+                        ],
+                    };
+                }
+                const newClaim = params.claim ?? current.claim;
+                const newReason = params.reason ?? current.reason;
+                const embeddingText = newReason
+                    ? `${newClaim} ${newReason}`
+                    : newClaim;
+                update.embedding = await generateEmbedding(embeddingText);
+            }
+            if (Object.keys(update).length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No fields to update. Provide at least one field to change.\n沒有要更新的欄位，請至少提供一個要變更的欄位。",
+                        },
+                    ],
+                };
+            }
+            let updateQuery = supabase
+                .from("traces")
+                .update(update)
+                .eq("id", params.trace_id);
+            if (userId)
+                updateQuery = updateQuery.eq("author", userId);
+            const { data, error } = await updateQuery
+                .select()
+                .single();
+            if (error) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Error updating trace: ${error.message}\n更新 trace 失敗：${error.message}`,
+                        },
+                    ],
+                };
+            }
+            if (userId)
+                audit(userId, "trace.update", "trace", params.trace_id);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            message: "Trace updated successfully / Trace 更新成功",
+                            trace: {
+                                id: data.id,
+                                claim: data.claim,
+                                reason: data.reason,
+                                status: data.status,
+                                superseded_by: data.superseded_by,
+                                tags: data.tags,
+                                confidence: data.confidence,
+                                updated_at: data.updated_at,
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                content: [{ type: "text", text: `Error: ${message}` }],
+            };
+        }
+    });
+}

package/dist/worker.d.ts

@@ -0,0 +1,15 @@
+export interface Env {
+    SUPABASE_URL: string;
+    SUPABASE_SERVICE_ROLE_KEY: string;
+    OPENAI_API_KEY: string;
+    OPENAI_EMBED_MODEL?: string;
+    GROQ_API_KEY?: string;
+    GROQ_CHAT_MODEL?: string;
+    ARCHIVE_BUCKET: R2Bucket;
+    RESEND_API_KEY?: string;
+}
+declare const _default: {
+    fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response>;
+    scheduled(event: ScheduledEvent, env: Env, ctx: ExecutionContext): Promise<void>;
+};
+export default _default;