@chigichan24/crune 0.1.0

package/dist-cli/session-summarizer.js

@@ -0,0 +1,133 @@
+import { tokenize } from "./knowledge-graph/tokenizer.js";
+import { STOP_WORDS } from "./knowledge-graph/constants.js";
+export function classifyWorkType(toolBreakdown, permissionMode, turnCount) {
+    const total = Object.values(toolBreakdown).reduce((a, b) => a + b, 0);
+    const readCount = (toolBreakdown["Read"] ?? 0) +
+        (toolBreakdown["Grep"] ?? 0) +
+        (toolBreakdown["Glob"] ?? 0);
+    const writeCount = (toolBreakdown["Edit"] ?? 0) + (toolBreakdown["Write"] ?? 0);
+    const bashCount = toolBreakdown["Bash"] ?? 0;
+    const writeRatio = total > 0 ? writeCount / total : 0;
+    const readRatio = total > 0 ? readCount / total : 0;
+    const bashRatio = total > 0 ? bashCount / total : 0;
+    if (total === 0 ||
+        (permissionMode === "plan" && turnCount < 5 && writeRatio === 0)) {
+        return "planning";
+    }
+    if (readRatio >= 0.7) {
+        return "investigation";
+    }
+    if (bashRatio >= 0.4 && writeCount > 0) {
+        return "debugging";
+    }
+    if (writeRatio >= 0.4) {
+        return "implementation";
+    }
+    return "implementation";
+}
+export function findCommonPathPrefix(paths) {
+    if (paths.length === 0)
+        return "";
+    const splitPaths = paths.map((p) => p.split("/"));
+    if (splitPaths.length === 1) {
+        // Single file: return its directory
+        const parts = splitPaths[0];
+        if (parts.length <= 1)
+            return "";
+        return parts.slice(0, -1).join("/");
+    }
+    const minLen = Math.min(...splitPaths.map((p) => p.length));
+    const commonParts = [];
+    for (let i = 0; i < minLen; i++) {
+        const segment = splitPaths[0][i];
+        if (splitPaths.every((p) => p[i] === segment)) {
+            commonParts.push(segment);
+        }
+        else {
+            break;
+        }
+    }
+    // Remove the last segment if it looks like a filename (has extension)
+    // The common prefix should be a directory
+    if (commonParts.length > 0) {
+        const last = commonParts[commonParts.length - 1];
+        if (last.includes(".")) {
+            commonParts.pop();
+        }
+    }
+    const result = commonParts.join("/");
+    if (result === "" || result === "/")
+        return "";
+    return result;
+}
+function selectRepresentativePrompt(prompts) {
+    if (prompts.length === 0)
+        return "";
+    if (prompts.length === 1)
+        return prompts[0].slice(0, 300);
+    const tokenSets = prompts.map((p) => new Set(tokenize(p)));
+    let bestIndex = 0;
+    let bestScore = -Infinity;
+    for (let i = 0; i < prompts.length; i++) {
+        let centralitySum = 0;
+        for (let j = 0; j < prompts.length; j++) {
+            if (i === j)
+                continue;
+            const intersection = new Set([...tokenSets[i]].filter((t) => tokenSets[j].has(t)));
+            const union = new Set([...tokenSets[i], ...tokenSets[j]]);
+            if (union.size > 0) {
+                centralitySum += intersection.size / union.size;
+            }
+        }
+        const positionWeight = 1 / (1 + i);
+        const score = centralitySum * positionWeight;
+        if (score > bestScore) {
+            bestScore = score;
+            bestIndex = i;
+        }
+    }
+    return prompts[bestIndex].slice(0, 300);
+}
+function extractKeywords(prompts) {
+    const allTokens = [];
+    for (const prompt of prompts) {
+        const tokens = tokenize(prompt);
+        for (const t of tokens) {
+            if (!STOP_WORDS.has(t)) {
+                allTokens.push(t);
+            }
+        }
+    }
+    const freq = new Map();
+    for (const t of allTokens) {
+        freq.set(t, (freq.get(t) ?? 0) + 1);
+    }
+    return [...freq.entries()]
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([word]) => word);
+}
+export function generateSessionSummary(turns, meta) {
+    // 1. Collect candidate prompts
+    let candidatePrompts = turns
+        .filter((t) => {
+        const mode = t.permissionMode ?? meta.permissionMode;
+        return mode === "plan";
+    })
+        .map((t) => t.userPrompt)
+        .filter((p) => p.trim().length > 0);
+    if (candidatePrompts.length === 0) {
+        candidatePrompts = turns
+            .map((t) => t.userPrompt)
+            .filter((p) => p.trim().length > 0);
+    }
+    // 2. Select representative prompt
+    const summary = selectRepresentativePrompt(candidatePrompts);
+    // 3. Extract keywords
+    const keywords = extractKeywords(candidatePrompts);
+    // 4. Determine workType
+    const workType = classifyWorkType(meta.toolBreakdown, meta.permissionMode, meta.turnCount);
+    // 5. Compute scope
+    const scope = findCommonPathPrefix(meta.filesEdited);
+    return { summary, keywords, scope, workType };
+}

package/dist-cli/skill-server.js

@@ -0,0 +1,62 @@
+import { createServer } from "node:http";
+import { buildSynthesisPrompt, synthesizeWithClaude } from "./skill-synthesizer.js";
+// ---------- Helpers ----------
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+        req.on("error", reject);
+    });
+}
+function sendJson(res, status, body) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(body));
+}
+// ---------- Request Handler ----------
+async function handleSynthesize(req, res) {
+    let body;
+    try {
+        const raw = await readBody(req);
+        body = JSON.parse(raw);
+    }
+    catch {
+        sendJson(res, 400, { success: false, error: "Invalid JSON in request body" });
+        return;
+    }
+    if (!body.skillCandidate || !body.topicNode) {
+        sendJson(res, 400, { success: false, error: "Missing required fields: skillCandidate, topicNode" });
+        return;
+    }
+    const prompt = buildSynthesisPrompt(body);
+    const result = await synthesizeWithClaude(prompt);
+    if (!result.success) {
+        sendJson(res, 500, { success: false, error: result.error });
+        return;
+    }
+    sendJson(res, 200, { success: true, synthesizedMarkdown: result.stdout });
+}
+// ---------- Server ----------
+const isDirectRun = process.argv[1]?.endsWith("skill-server.ts") || process.argv[1]?.endsWith("skill-server.js");
+if (isDirectRun) {
+    const PORT = 3456;
+    const server = createServer(async (req, res) => {
+        if (req.method === "POST" && req.url === "/api/synthesize") {
+            await handleSynthesize(req, res);
+        }
+        else {
+            sendJson(res, 404, { error: "Not found" });
+        }
+    });
+    server.listen(PORT, () => {
+        console.log(`Skill synthesis server listening on http://localhost:${PORT}`);
+    });
+    function shutdown() {
+        console.log("\nShutting down...");
+        server.close(() => {
+            process.exit(0);
+        });
+    }
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}

package/dist-cli/skill-synthesizer.js

@@ -0,0 +1,189 @@
+import { spawn } from "node:child_process";
+// ---------- Prompt Builder ----------
+export function buildSynthesisPrompt(body) {
+    const { skillCandidate, topicNode, enrichedSequences, graphContext } = body;
+    const topicInfo = [
+        `## Topic Information`,
+        `- **Label:** ${topicNode.label}`,
+        `- **Keywords:** ${topicNode.keywords.join(", ")}`,
+        `- **Dominant Role:** ${topicNode.dominantRole}`,
+        `- **Projects:** ${topicNode.projects.join(", ")}`,
+        `- **Session Count:** ${topicNode.sessionCount}`,
+        `- **Total Duration:** ${topicNode.totalDurationMinutes} minutes`,
+    ].join("\n");
+    const prompts = topicNode.representativePrompts.length > 0
+        ? [
+            `## Representative User Prompts`,
+            ...topicNode.representativePrompts.map((p, i) => `${i + 1}. ${p}`),
+        ].join("\n")
+        : "";
+    const toolSig = [
+        `## Tool Signature`,
+        ...topicNode.toolSignature.map((t) => `- ${t.tool}: ${(t.weight * 100).toFixed(1)}%`),
+    ].join("\n");
+    let toolPatterns = "";
+    if (enrichedSequences && enrichedSequences.length > 0) {
+        const top5 = enrichedSequences.slice(0, 5);
+        const flows = top5.map((seq) => {
+            const flow = seq.sequence.map((s) => s.toolName).join(" → ");
+            return `- ${flow} (${seq.count}x across ${seq.projects.length} project(s))`;
+        });
+        toolPatterns = [`## Enriched Tool Patterns`, ...flows].join("\n");
+    }
+    // --- Graph context sections ---
+    let graphPosition = "";
+    let connectedTopicsSection = "";
+    if (graphContext) {
+        // Graph Position section
+        const positionLines = [`## Graph Position`];
+        const betweenness = topicNode.betweennessCentrality;
+        const degree = topicNode.degreeCentrality;
+        if (betweenness > 0.2) {
+            positionLines.push("- This is a critical bridge topic connecting multiple knowledge domains");
+        }
+        else if (betweenness > 0.05) {
+            positionLines.push("- This topic bridges several knowledge domains");
+        }
+        else if (degree > 0.5) {
+            positionLines.push("- This is a hub topic connected to many other topics");
+        }
+        else if (degree === 0) {
+            positionLines.push("- This is an isolated topic with no connections to other topics");
+        }
+        else {
+            positionLines.push("- This is a peripheral topic");
+        }
+        if (graphContext.community) {
+            positionLines.push(`- Belongs to community: ${graphContext.community.label} (${graphContext.community.memberCount} topics)`);
+        }
+        if (graphContext.isBridgeTopic) {
+            positionLines.push("- Identified as a bridge topic in the knowledge graph");
+        }
+        graphPosition = positionLines.join("\n");
+        // Connected Topics section
+        if (graphContext.connectedTopics.length > 0) {
+            const grouped = {};
+            for (const ct of graphContext.connectedTopics) {
+                if (!grouped[ct.edgeType]) {
+                    grouped[ct.edgeType] = [];
+                }
+                const kw = ct.keywords.join(", ");
+                if (ct.edgeType === "workflow-continuation") {
+                    if (ct.direction === "incoming") {
+                        grouped[ct.edgeType].push(`- Prerequisite: ${ct.label} [${kw}] (strength: ${ct.strength})`);
+                    }
+                    else {
+                        grouped[ct.edgeType].push(`- Follow-up: ${ct.label} [${kw}] (strength: ${ct.strength})`);
+                    }
+                }
+                else if (ct.edgeType === "shared-module") {
+                    grouped[ct.edgeType].push(`- Related (shared files): ${ct.label} [${kw}]`);
+                }
+                else if (ct.edgeType === "cross-project-bridge") {
+                    grouped[ct.edgeType].push(`- Cross-project link: ${ct.label} [${kw}]`);
+                }
+                else if (ct.edgeType === "semantic-similarity") {
+                    grouped[ct.edgeType].push(`- Similar topic (differentiate from): ${ct.label} [${kw}]`);
+                }
+            }
+            const lines = [`## Connected Topics`];
+            if (grouped["workflow-continuation"]) {
+                lines.push("### Workflow Continuation");
+                lines.push(...grouped["workflow-continuation"]);
+            }
+            if (grouped["shared-module"]) {
+                lines.push("### Shared Module");
+                lines.push(...grouped["shared-module"]);
+            }
+            if (grouped["cross-project-bridge"]) {
+                lines.push("### Cross-Project Bridge");
+                lines.push(...grouped["cross-project-bridge"]);
+            }
+            if (grouped["semantic-similarity"]) {
+                lines.push("### Semantic Similarity");
+                lines.push(...grouped["semantic-similarity"]);
+            }
+            connectedTopicsSection = lines.join("\n");
+        }
+    }
+    const reference = [
+        `## Current Heuristic-Generated Skill (for reference)`,
+        "```",
+        skillCandidate.skillMarkdown,
+        "```",
+    ].join("\n");
+    const instructionLines = [
+        `## Your Task`,
+        `Produce a refined SKILL.md for this workflow following anthropics/skills conventions. Rules:`,
+        ``,
+        `1. Start with YAML frontmatter containing \`name\` and \`description\`. The description MUST include an explicit "when to use" trigger (pushiness) so Claude knows when to activate this skill. Counter under-triggering by being specific about activation context.`,
+        `2. Use concise, imperative writing style throughout.`,
+        `3. Structure the body with these sections:`,
+        `   - **Overview**: What this skill automates and why (1-2 sentences)`,
+        `   - **When to Use**: Explicit trigger patterns with concrete examples from the representative prompts above`,
+        `   - **Workflow**: Step-by-step imperative instructions using the detected tool patterns`,
+        `   - **Guidelines**: "Why"-based rules (not bare MUST/NEVER). Each guideline explains reasoning.`,
+        `4. Include concrete examples drawn from the representative prompts above.`,
+        `5. Focus on the ESSENCE of what makes this workflow distinct and reusable. Progressive disclosure: keep body scannable.`,
+        `6. Write the body in Japanese. Skill names, tool names, technical terms, and proper nouns should remain in English.`,
+        `7. Output ONLY the markdown content. No code fences wrapping the output, no explanations before or after.`,
+    ];
+    if (graphContext && graphContext.connectedTopics.some(ct => ct.edgeType === "workflow-continuation")) {
+        instructionLines.push(`8. If workflow-continuation connections exist, include \`requires\` and/or \`next\` fields in the YAML frontmatter listing the connected topic labels.`);
+    }
+    const instruction = instructionLines.join("\n");
+    const parts = [topicInfo, prompts, toolSig, toolPatterns, graphPosition, connectedTopicsSection, reference, instruction].filter(Boolean);
+    return parts.join("\n\n");
+}
+export function synthesizeWithClaude(prompt, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    return new Promise((resolve) => {
+        const args = ["-p", "--output-format", "text"];
+        if (options.model) {
+            args.push("--model", options.model);
+        }
+        const child = spawn("claude", args, {
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let notFound = false;
+        child.on("error", (err) => {
+            if (err.code === "ENOENT") {
+                notFound = true;
+                resolve({ success: false, stdout: "", stderr: "", error: "claude CLI not found. Install Claude Code first." });
+            }
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+        child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+        const timeout = setTimeout(() => {
+            child.kill("SIGKILL");
+            resolve({
+                success: false,
+                stdout: "",
+                stderr: "",
+                error: `Synthesis timed out (${timeoutMs / 1000}s)`,
+            });
+        }, timeoutMs);
+        child.on("close", (code) => {
+            clearTimeout(timeout);
+            if (!notFound) {
+                const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
+                const stderr = Buffer.concat(stderrChunks).toString("utf-8");
+                if (code !== 0) {
+                    resolve({
+                        success: false,
+                        stdout: "",
+                        stderr,
+                        error: `claude exited with code ${code}: ${stderr}`,
+                    });
+                }
+                else {
+                    resolve({ success: true, stdout, stderr: "" });
+                }
+            }
+        });
+        child.stdin.write(prompt);
+        child.stdin.end();
+    });
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@chigichan24/crune",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "crune": "./bin/crune.js"
+  },
+  "files": [
+    "dist-cli/",
+    "bin/"
+  ],
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "build:cli": "tsc -p tsconfig.cli.json",
+    "lint": "eslint .",
+    "preview": "vite preview",
+    "analyze-sessions": "tsx scripts/analyze-sessions.ts",
+    "skill-server": "tsx scripts/skill-server.ts",
+    "dev:full": "npm run skill-server & npm run dev",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build:cli"
+  },
+  "dependencies": {
+    "chart.js": "^4.5.1",
+    "react": "^19.2.4",
+    "react-chartjs-2": "^5.3.1",
+    "react-dom": "^19.2.4",
+    "react-force-graph-2d": "^1.29.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.4",
+    "@types/node": "^24.12.0",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.0",
+    "eslint": "^9.39.4",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "globals": "^17.4.0",
+    "tsx": "^4.21.0",
+    "typescript": "~5.9.3",
+    "typescript-eslint": "^8.56.1",
+    "vite": "^8.0.0",
+    "vitest": "^3.2.4"
+  }
+}