skill-tree-ai 1.0.0

package/dist/core/render.js

@@ -0,0 +1,58 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+function getTemplateDir() {
+    // Try relative to this file first (works in dev and dist)
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    // In dist/core/render.js → templates is at ../../templates
+    const distPath = join(thisDir, "..", "..", "templates");
+    if (existsSync(distPath))
+        return distPath;
+    // In src/core/render.ts → templates is at ../../templates
+    const srcPath = join(thisDir, "..", "..", "templates");
+    if (existsSync(srcPath))
+        return srcPath;
+    // Fallback: look in cwd
+    const cwdPath = join(process.cwd(), "templates");
+    if (existsSync(cwdPath))
+        return cwdPath;
+    throw new Error("Cannot find templates directory");
+}
+function getOutputDir() {
+    const dir = join(homedir(), ".skill-tree");
+    return dir;
+}
+export function renderHTML(profile) {
+    const templatePath = join(getTemplateDir(), "skill-tree.html");
+    const template = readFileSync(templatePath, "utf-8");
+    // Escape </script> in JSON to prevent HTML parser breaking
+    const jsonStr = JSON.stringify(profile).replace(/<\/script>/gi, "<\\/script>");
+    return template.replace("__PROFILE_DATA__", jsonStr);
+}
+export function writeAndOpen(profile) {
+    const html = renderHTML(profile);
+    const outputPath = join(getOutputDir(), "report.html");
+    writeFileSync(outputPath, html);
+    return outputPath;
+}
+export async function openInBrowser(filePath) {
+    const platform = process.platform;
+    try {
+        if (platform === "darwin") {
+            await execFileAsync("open", [filePath]);
+        }
+        else if (platform === "linux") {
+            await execFileAsync("xdg-open", [filePath]);
+        }
+        else if (platform === "win32") {
+            await execFileAsync("cmd", ["/c", "start", filePath]);
+        }
+    }
+    catch {
+        // Silent — caller has the path
+    }
+}

package/dist/index.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+const isRemote = process.argv.includes("--remote") ||
+    process.env.SKILL_TREE_REMOTE === "1";
+if (isRemote) {
+    await import("./remote.js");
+}
+else {
+    await import("./local.js");
+}
+export {};

package/dist/local.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.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 { writeAndOpen, openInBrowser } from "./core/render.js";
+import { MCP_INSTRUCTIONS } from "./shared.js";
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+// --- State & Persistence ---
+let cachedProfile = null;
+function getSkillTreeDir() {
+    const dir = join(homedir(), ".skill-tree");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function getProfilePath() {
+    return join(getSkillTreeDir(), "profile.json");
+}
+function getHistoryDir() {
+    const dir = join(getSkillTreeDir(), "history");
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function loadCachedProfile() {
+    const path = getProfilePath();
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+function saveProfile(profile) {
+    const dir = getSkillTreeDir();
+    // Save current profile
+    writeFileSync(join(dir, "profile.json"), JSON.stringify(profile, null, 2));
+    // Save timestamped snapshot for progress tracking
+    const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    writeFileSync(join(getHistoryDir(), `profile-${ts}.json`), JSON.stringify(profile, null, 2));
+    // Write growth-quest.txt for SessionStart hook
+    writeFileSync(join(dir, "growth-quest.txt"), profile.archetype.growth_quest);
+}
+// --- MCP Server ---
+const server = new McpServer({ name: "skill-tree-ai", version: "1.0.0" }, { instructions: MCP_INSTRUCTIONS });
+server.tool("analyze", "Analyze your Claude conversation history. Scans Claude Code and Cowork sessions, classifies 11 AI collaboration behaviors, builds a skill profile with character archetype and growth recommendation. Returns the full profile.", {
+    max_sessions: z
+        .number()
+        .default(100)
+        .describe("Maximum number of sessions to analyze (most recent first)"),
+    force_refresh: z
+        .boolean()
+        .default(false)
+        .describe("Force re-analysis even if cached results exist"),
+}, async ({ max_sessions, force_refresh }) => {
+    // Check cache unless forced
+    if (!force_refresh) {
+        const cached = loadCachedProfile();
+        if (cached) {
+            cachedProfile = cached;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: formatProfileSummary(cached),
+                    },
+                ],
+            };
+        }
+    }
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Error: ANTHROPIC_API_KEY not set. Set it in your environment to enable skill tree analysis.",
+                },
+            ],
+        };
+    }
+    const client = new Anthropic({ apiKey });
+    // Extract sessions
+    const sessions = findAllSessions(max_sessions);
+    if (sessions.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "No conversation sessions found. Make sure you have Claude Code or Cowork conversations on this machine.",
+                },
+            ],
+        };
+    }
+    // Classify (uses per-session cache — only new sessions hit the API)
+    const classifications = await classifySessions(client, sessions.map((s) => ({
+        sessionId: s.sessionId,
+        messages: s.messages,
+    })), 50);
+    // Build profile (deterministic — no LLM call)
+    const previousProfile = loadCachedProfile();
+    const profile = buildProfile(classifications, previousProfile);
+    cachedProfile = profile;
+    saveProfile(profile);
+    return {
+        content: [
+            {
+                type: "text",
+                text: formatProfileSummary(profile),
+            },
+        ],
+    };
+});
+server.tool("visualize", "Generate a beautiful HTML skill tree visualization and open it in your browser. Run 'analyze' first to generate the profile data.", {}, async () => {
+    const profile = cachedProfile || loadCachedProfile();
+    if (!profile) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "No profile data available. Run the 'analyze' tool first.",
+                },
+            ],
+        };
+    }
+    const outputPath = writeAndOpen(profile);
+    await openInBrowser(outputPath);
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Skill tree visualization generated and opened in browser.\nFile: ${outputPath}`,
+            },
+        ],
+    };
+});
+server.tool("growth_quest", "Get your current growth recommendation — one specific thing to try in your next session, based on your archetype's growth path.", {}, async () => {
+    const profile = cachedProfile || loadCachedProfile();
+    if (!profile) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "No profile data available. Run the 'analyze' tool first to get personalized recommendations.",
+                },
+            ],
+        };
+    }
+    const a = profile.archetype;
+    const ge = profile.growth_edge;
+    const userPct = Math.round(ge.rate * 100);
+    const basePct = Math.round(ge.baseline * 100);
+    return {
+        content: [
+            {
+                type: "text",
+                text: [
+                    `${a.name} — ${a.tagline}`,
+                    ``,
+                    `Superpower: ${a.superpower}`,
+                    ``,
+                    `Next Unlock: ${a.growth_unlock}`,
+                    ``,
+                    `Quest: ${a.growth_quest}`,
+                    ``,
+                    `Growth edge: ${ge.label} — you're at ${userPct}%, population average is ${basePct}%`,
+                ].join("\n"),
+            },
+        ],
+    };
+});
+// --- Format helpers ---
+function formatProfileSummary(profile) {
+    const a = profile.archetype;
+    const lines = [
+        `╔══════════════════════════════════════╗`,
+        `║  ${a.name.padStart(18).padEnd(36)}║`,
+        `╚══════════════════════════════════════╝`,
+        `"${a.tagline}"`,
+        ``,
+        `Superpower: ${a.superpower}`,
+        ``,
+        `─── Skill Profile (${profile.total_sessions} sessions) ───`,
+        ``,
+    ];
+    for (const [axisName, axis] of Object.entries(profile.branches)) {
+        const indicator = axis.above_baseline ? "+" : "-";
+        lines.push(`${axisName} (${indicator} vs avg):`);
+        for (const key of axis.behaviors) {
+            const b = profile.behaviors[key];
+            if (!b)
+                continue;
+            const pct = Math.round(b.rate * 100);
+            const basePct = Math.round(b.baseline * 100);
+            const arrow = b.above_baseline ? "↑" : "↓";
+            const bar = "■".repeat(Math.round(pct / 10)) +
+                "□".repeat(10 - Math.round(pct / 10));
+            lines.push(`  ${bar} ${pct}% ${b.label} (avg: ${basePct}%) ${arrow}`);
+        }
+        lines.push(``);
+    }
+    const ge = profile.growth_edge;
+    lines.push(`Next Unlock: ${a.growth_unlock}`);
+    lines.push(`Quest: ${a.growth_quest}`);
+    if (profile.previous_archetype && profile.previous_archetype !== a.key) {
+        lines.push(`\nProgress: Archetype changed from ${profile.previous_archetype} → ${a.key}`);
+    }
+    return lines.join("\n");
+}
+// --- Start ---
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/remote.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+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 { 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() {
+    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 }) => {
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            return {
+                content: [{ type: "text", text: "Error: ANTHROPIC_API_KEY not configured on server." }],
+            };
+        }
+        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." }],
+            };
+        }
+        const classifications = await classifySessions(client, sessions.map((s) => ({ sessionId: s.sessionId, messages: s.messages })), 20);
+        const profile = buildProfile(classifications);
+        return {
+            content: [
+                { type: "text", text: JSON.stringify(profile, null, 2) },
+            ],
+        };
+    });
+    // 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() });
+    server.connect(transport);
+    return { server, transport };
+}
+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");
+    if (req.method === "OPTIONS") {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+    if (url.pathname === "/health") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok", sessions: sessions.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));
+        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/dist/shared.js

@@ -0,0 +1,16 @@
+export const MCP_INSTRUCTIONS = `Skill Tree analyzes your Claude conversation history to reveal your AI collaboration style.
+
+It classifies 11 observable behaviors from the AI Fluency Framework across your sessions, builds a skill profile, and generates a character archetype card with a personalized growth recommendation.
+
+## Tools
+
+- **analyze**: Scans your conversation history (Claude Code + Cowork), classifies behaviors, and returns your full skill profile with archetype and growth edge. Run this first.
+- **visualize**: Generates a beautiful HTML skill tree visualization and opens it in your browser. Requires a profile from analyze.
+- **growth_quest**: Returns your current recommended challenge — one specific thing to try in your next session.
+
+## When to use
+
+Use \`analyze\` when the user asks about their Claude usage style, wants to see their skill tree, or runs /skill-tree.
+Use \`visualize\` after analyze to show the results.
+Use \`growth_quest\` when the user wants a quick recommendation without the full analysis.
+`;

package/hooks/hooks.json

@@ -0,0 +1,15 @@
+{
+  "description": "Skill tree growth quest — injects your active challenge into each session",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash \"${CLAUDE_PLUGIN_ROOT}/hooks-handlers/session-start.sh\""
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks-handlers/session-start.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# Inject the active growth quest into the session context.
+# Reads from ~/.skill-tree/growth-quest.txt (written by profile.py after /skill-tree runs).
+
+QUEST_FILE="$HOME/.skill-tree/growth-quest.txt"
+
+if [ -f "$QUEST_FILE" ] && [ -s "$QUEST_FILE" ]; then
+  QUEST=$(cat "$QUEST_FILE")
+  cat << EOF
+{
+  "hookSpecificOutput": {
+    "hookEventName": "SessionStart",
+    "additionalContext": "Skill Tree growth quest active: ${QUEST} — If a natural opportunity arises during this session, gently encourage the user to practice this behavior. Do not force it or mention this unless relevant."
+  }
+}
+EOF
+else
+  # No quest yet — user hasn't run /skill-tree
+  cat << 'EOF'
+{
+  "hookSpecificOutput": {
+    "hookEventName": "SessionStart",
+    "additionalContext": ""
+  }
+}
+EOF
+fi
+
+exit 0

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "skill-tree-ai",
+  "version": "1.0.0",
+  "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": {
+    "skill-tree-ai": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "templates",
+    "skills",
+    ".claude-plugin",
+    ".mcp.json",
+    "hooks",
+    "hooks-handlers"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "start:remote": "SKILL_TREE_REMOTE=1 node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "dev:remote": "SKILL_TREE_REMOTE=1 tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "claude-code",
+    "skill-tree",
+    "ai-fluency",
+    "mcp-server",
+    "education"
+  ],
+  "license": "MIT",
+  "author": "Robert Nowell",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.39.0",
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3"
+  }
+}

package/skills/skill-tree/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: skill-tree
+description: Analyze your Claude collaboration style and generate a skill tree visualization with character archetype card. Use when the user says "skill tree", "show my skills", "analyze my style", or wants to see their AI fluency profile.
+---
+
+# Skill Tree
+
+Generate a personalized AI fluency profile by analyzing the user's Claude conversation history.
+
+## Workflow
+
+Use the MCP tools in this order:
+
+1. Call the **`analyze`** tool — this scans your Claude Code and Cowork conversation history, classifies 11 AI collaboration behaviors using Claude Haiku, and returns your full skill profile with character archetype.
+
+2. Call the **`visualize`** tool — this generates a beautiful HTML skill tree visualization and opens it in your browser.
+
+3. Present the results to the user — show the archetype card, key strengths, and growth quest.
+
+If the user just wants a quick recommendation without the full analysis, use the **`growth_quest`** tool.
+
+## Requirements
+
+- `ANTHROPIC_API_KEY` environment variable must be set (for behavioral classification via Claude Haiku)
+- If not set, the tools will return an error with setup instructions
+
+## What It Shows
+
+- **Character Card**: Your archetype name, tagline, signature strengths, and vibe
+- **Skill Tree**: 11 behaviors across 4 branches (Planning, Craft, Judgment, Rigor) with animated bars and population baseline markers
+- **Growth Quest**: Your "next unlock" — one specific challenge for your next session
+
+## The 11 Behaviors (from AI Fluency Framework)
+
+| Branch | Behavior | Population Avg |
+|--------|----------|---------------|
+| Planning | Clarifies goals upfront | 51% |
+| Planning | Discusses approach first | 10% |
+| Craft | Iterates on outputs | 86% |
+| Craft | Provides examples | 41% |
+| Craft | Specifies format | 30% |
+| Craft | Sets interaction style | 30% |
+| Craft | Expresses tone preferences | 23% |
+| Craft | Defines audience | 18% |
+| Judgment | Flags context gaps | 20% |
+| Judgment | Questions Claude's logic | 16% |
+| Rigor | Verifies facts | 9% |
+
+Baselines from [Anthropic's AI Fluency Index](https://www.anthropic.com/research/AI-fluency-index) (Feb 2026, N=9,830 conversations).