skill-tree-ai 1.0.0 → 1.0.1

package/dist/core/classify.js

@@ -152,20 +152,27 @@ export async function classifySession(client, sessionId, messages) {
     return classification;
 }
 export async function classifySessions(client, sessions, maxNew = 50, onProgress) {
-    const results = [];
-    let newClassified = 0;
-    for (let i = 0; i < sessions.length; i++) {
-        const session = sessions[i];
+    // Split into cached (instant) and uncached (needs API call)
+    const cachedResults = [];
+    const uncachedSessions = [];
+    for (const session of sessions) {
         const cached = getCachedClassification(session.sessionId);
         if (cached) {
-            results.push(cached);
+            cachedResults.push(cached);
         }
-        else if (newClassified < maxNew) {
-            const classification = await classifySession(client, session.sessionId, session.messages);
-            results.push(classification);
-            newClassified++;
+        else {
+            uncachedSessions.push(session);
         }
-        onProgress?.(i + 1, sessions.length);
     }
-    return results;
+    // Classify uncached sessions in parallel batches (8 at a time)
+    const BATCH_SIZE = 8;
+    const uncachedResults = [];
+    const toClassify = uncachedSessions.slice(0, maxNew);
+    for (let i = 0; i < toClassify.length; i += BATCH_SIZE) {
+        const batch = toClassify.slice(i, i + BATCH_SIZE);
+        const batchResults = await Promise.all(batch.map((s) => classifySession(client, s.sessionId, s.messages)));
+        uncachedResults.push(...batchResults);
+        onProgress?.(cachedResults.length + uncachedResults.length, sessions.length);
+    }
+    return [...cachedResults, ...uncachedResults];
 }

package/dist/remote.js

@@ -1,70 +1,123 @@
 #!/usr/bin/env node
+/**
+ * Remote MCP server for skill-tree.
+ *
+ * Deployed to Fly.io. Accepts conversation data from the client (Claude reads
+ * local files and sends them here), classifies with Haiku using the server's
+ * API key, and returns the profile. The user never needs an API key.
+ */
 import { createServer } from "node:http";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport, } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { z } from "zod";
 import Anthropic from "@anthropic-ai/sdk";
-import { findAllSessions } from "./core/extract.js";
 import { classifySessions } from "./core/classify.js";
-import { buildProfile } from "./core/profile.js";
+import { buildProfile, ARCHETYPES } from "./core/profile.js";
 import { renderHTML } from "./core/render.js";
 import { MCP_INSTRUCTIONS } from "./shared.js";
 import { randomUUID } from "node:crypto";
 const PORT = parseInt(process.env.PORT || "3000", 10);
-// Per-session MCP servers
-const sessions = new Map();
-function createSessionServer() {
+// Map from transport session ID → { server, transport }
+const activeSessions = new Map();
+function createMcpSession() {
     const server = new McpServer({ name: "skill-tree-ai", version: "1.0.0" }, { instructions: MCP_INSTRUCTIONS });
-    // analyze tool (simplified for remote — operates on provided data or sample)
-    server.tool("analyze", "Analyze conversation history and return skill profile.", {
-        conversation_json: z
-            .string()
-            .optional()
-            .describe("Optional: paste conversation JSONL content to analyze"),
-    }, async ({ conversation_json }) => {
+    server.tool("analyze", "Analyze conversation data and return a skill profile with archetype. " +
+        "The client (Claude) should read the user's local JSONL session files, " +
+        "extract user messages, and pass them here as sessions_json.", {
+        sessions_json: z.string().describe('JSON array of sessions: [{"id":"...","messages":["msg1","msg2",...]}]'),
+    }, async ({ sessions_json }) => {
         const apiKey = process.env.ANTHROPIC_API_KEY;
         if (!apiKey) {
-            return {
-                content: [{ type: "text", text: "Error: ANTHROPIC_API_KEY not configured on server." }],
-            };
+            return { content: [{ type: "text", text: "Error: Server API key not configured." }] };
         }
-        const client = new Anthropic({ apiKey });
-        // If conversation_json provided, analyze it directly
-        // Otherwise, analyze local sessions (server-side)
-        const sessions = findAllSessions(50);
-        if (sessions.length === 0) {
-            return {
-                content: [{ type: "text", text: "No sessions found on this machine." }],
-            };
+        let parsed;
+        try {
+            parsed = JSON.parse(sessions_json);
+        }
+        catch {
+            return { content: [{ type: "text", text: "Error: Invalid JSON." }] };
+        }
+        if (!Array.isArray(parsed) || parsed.length === 0) {
+            return { content: [{ type: "text", text: "No sessions provided." }] };
         }
-        const classifications = await classifySessions(client, sessions.map((s) => ({ sessionId: s.sessionId, messages: s.messages })), 20);
+        const client = new Anthropic({ apiKey });
+        const sessionsForClassifier = parsed.map((s) => ({
+            sessionId: s.id || randomUUID().slice(0, 8),
+            messages: (s.messages || []).map((text) => ({
+                text: String(text).slice(0, 2000),
+                rawLength: String(text).length,
+                cleanedLength: Math.min(String(text).length, 2000),
+            })),
+        }));
+        const classifications = await classifySessions(client, sessionsForClassifier, 50);
         const profile = buildProfile(classifications);
-        return {
-            content: [
-                { type: "text", text: JSON.stringify(profile, null, 2) },
-            ],
-        };
+        return { content: [{ type: "text", text: JSON.stringify(profile) }] };
+    });
+    server.tool("visualize", "Generate HTML skill tree visualization from profile JSON.", { profile_json: z.string().describe("Profile JSON from analyze") }, async ({ profile_json }) => {
+        const html = renderHTML(JSON.parse(profile_json));
+        return { content: [{ type: "text", text: html }] };
+    });
+    server.tool("archetypes", "List all 7 archetypes.", {}, async () => {
+        const list = Object.entries(ARCHETYPES)
+            .map(([, a]) => `**${a.name}** — ${a.tagline}`)
+            .join("\n\n");
+        return { content: [{ type: "text", text: list }] };
     });
-    // visualize tool — returns HTML string
-    server.tool("visualize", "Generate HTML visualization from a profile.", {
-        profile_json: z.string().describe("Profile JSON from the analyze tool"),
-    }, async ({ profile_json }) => {
-        const profile = JSON.parse(profile_json);
-        const html = renderHTML(profile);
-        return {
-            content: [{ type: "text", text: html }],
-        };
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
     });
-    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: () => randomUUID() });
+    transport.onclose = () => {
+        const sid = transport.sessionId;
+        if (sid)
+            activeSessions.delete(sid);
+    };
     server.connect(transport);
     return { server, transport };
 }
+async function handleMcp(req, res) {
+    const sessionId = req.headers["mcp-session-id"];
+    if (sessionId && activeSessions.has(sessionId)) {
+        // Existing session
+        const { transport } = activeSessions.get(sessionId);
+        await transport.handleRequest(req, res, await readBody(req));
+    }
+    else if (!sessionId) {
+        // New session — create server + transport, let transport assign session ID
+        const session = createMcpSession();
+        // Handle the request — transport will set mcp-session-id header in response
+        await session.transport.handleRequest(req, res, await readBody(req));
+        // After handling, get the session ID the transport assigned
+        const newSid = session.transport.sessionId;
+        if (newSid) {
+            activeSessions.set(newSid, session);
+        }
+    }
+    else {
+        // Session ID provided but not found — stale session
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32000, message: "Session expired" }, id: null }));
+    }
+}
+function readBody(req) {
+    return new Promise((resolve) => {
+        let body = "";
+        req.on("data", (chunk) => (body += chunk));
+        req.on("end", () => {
+            try {
+                resolve(JSON.parse(body));
+            }
+            catch {
+                resolve(body);
+            }
+        });
+    });
+}
 const httpServer = createServer(async (req, res) => {
     const url = new URL(req.url || "/", `http://localhost:${PORT}`);
-    // CORS
     res.setHeader("Access-Control-Allow-Origin", "*");
     res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE");
     res.setHeader("Access-Control-Allow-Headers", "Content-Type, mcp-session-id");
+    res.setHeader("Access-Control-Expose-Headers", "mcp-session-id");
     if (req.method === "OPTIONS") {
         res.writeHead(204);
         res.end();
@@ -72,42 +125,16 @@ const httpServer = createServer(async (req, res) => {
     }
     if (url.pathname === "/health") {
         res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ status: "ok", sessions: sessions.size }));
+        res.end(JSON.stringify({ status: "ok", sessions: activeSessions.size }));
         return;
     }
     if (url.pathname === "/mcp" && req.method === "POST") {
-        const sessionId = req.headers["mcp-session-id"];
-        let session;
-        if (sessionId && sessions.has(sessionId)) {
-            session = sessions.get(sessionId);
-        }
-        else {
-            session = createSessionServer();
-            const newId = randomUUID();
-            sessions.set(newId, session);
-            res.setHeader("mcp-session-id", newId);
-        }
-        // Forward request to transport
-        await session.transport.handleRequest(req, res, await readBody(req));
+        await handleMcp(req, res);
         return;
     }
     res.writeHead(404);
     res.end("Not found");
 });
-function readBody(req) {
-    return new Promise((resolve) => {
-        let body = "";
-        req.on("data", (chunk) => (body += chunk));
-        req.on("end", () => {
-            try {
-                resolve(JSON.parse(body));
-            }
-            catch {
-                resolve(body);
-            }
-        });
-    });
-}
 httpServer.listen(PORT, () => {
     console.error(`Skill Tree MCP server running on http://localhost:${PORT}/mcp`);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skill-tree-ai",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "type": "module",
   "description": "Your AI collaboration style — skill tree visualization with character archetype cards and growth recommendations, grounded in the AI Fluency Framework. MCP server for Claude Code.",
   "bin": {