@chigichan24/crune 0.1.0

package/dist-cli/knowledge-graph/topic-nodes.js

@@ -0,0 +1,199 @@
+/**
+ * Topic node construction from session clusters.
+ */
+import { ACTION_VERBS_EN, ACTION_VERBS_JA } from "./constants.js";
+import { cosineSimilarity } from "./similarity.js";
+export function extractDominantAction(prompts) {
+    const actionCounts = new Map();
+    for (const prompt of prompts) {
+        const lower = prompt.toLowerCase();
+        // English verbs
+        const words = lower.split(/\s+/);
+        for (const w of words) {
+            const clean = w.replace(/[^a-z]/g, "");
+            if (ACTION_VERBS_EN.has(clean)) {
+                actionCounts.set(clean, (actionCounts.get(clean) || 0) + 1);
+            }
+        }
+        // Japanese verbs
+        for (const [pattern, verb] of ACTION_VERBS_JA) {
+            if (pattern.test(prompt)) {
+                actionCounts.set(verb, (actionCounts.get(verb) || 0) + 1);
+            }
+        }
+    }
+    if (actionCounts.size === 0)
+        return "work on";
+    return [...actionCounts.entries()].sort((a, b) => b[1] - a[1])[0][0];
+}
+export function selectRepresentativePrompts(memberSessions, clusterCentroid, tfidfResult, maxCount = 3) {
+    const scored = [];
+    for (const s of memberSessions) {
+        const sessionVec = tfidfResult.vectors.get(s.sessionId);
+        if (!sessionVec)
+            continue;
+        const sim = cosineSimilarity(sessionVec, clusterCentroid);
+        for (const turn of s.turns) {
+            if (turn.userPrompt && turn.userPrompt.length > 10) {
+                scored.push({ prompt: turn.userPrompt, score: sim });
+            }
+        }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    // Deduplicate similar prompts
+    const selected = [];
+    for (const { prompt } of scored) {
+        const trimmed = prompt.length > 150 ? prompt.slice(0, 150) + "..." : prompt;
+        if (!selected.some((s) => s === trimmed)) {
+            selected.push(trimmed);
+            if (selected.length >= maxCount)
+                break;
+        }
+    }
+    return selected;
+}
+export function generateSuggestedPrompt(memberSessions, keywords, toolIdf) {
+    // Collect all user prompts
+    const allPrompts = memberSessions.flatMap((s) => s.turns.map((t) => t.userPrompt).filter(Boolean));
+    // Extract dominant action
+    const action = extractDominantAction(allPrompts);
+    // Domain keywords (top 3)
+    const domain = keywords.slice(0, 3).join("/");
+    // Top tools by Tool-IDF weighted usage in this cluster
+    const clusterToolCounts = new Map();
+    for (const s of memberSessions) {
+        for (const [tool, count] of Object.entries(s.meta.toolBreakdown)) {
+            clusterToolCounts.set(tool, (clusterToolCounts.get(tool) || 0) + count);
+        }
+    }
+    const toolScores = [...clusterToolCounts.entries()].map(([tool, count]) => ({
+        tool,
+        score: Math.log(1 + count) * (toolIdf.toolIdfWeights.get(tool) || 1),
+    }));
+    toolScores.sort((a, b) => b.score - a.score);
+    const topTools = toolScores.slice(0, 3).map((t) => t.tool);
+    return `${action} ${domain} — tools: ${topTools.join(", ")}`;
+}
+export function computeToolSignature(memberSessions, toolIdf) {
+    const clusterToolCounts = new Map();
+    for (const s of memberSessions) {
+        for (const [tool, count] of Object.entries(s.meta.toolBreakdown)) {
+            clusterToolCounts.set(tool, (clusterToolCounts.get(tool) || 0) + count);
+        }
+    }
+    const scored = [...clusterToolCounts.entries()].map(([tool, count]) => ({
+        tool,
+        weight: Math.round(Math.log(1 + count) * (toolIdf.toolIdfWeights.get(tool) || 1) * 100) / 100,
+    }));
+    scored.sort((a, b) => b.weight - a.weight);
+    return scored.slice(0, 5);
+}
+export function classifyDominantRole(memberSessions) {
+    let totalUserTurns = 0;
+    let totalToolCalls = 0;
+    let totalSubagentCalls = 0;
+    for (const s of memberSessions) {
+        for (const turn of s.turns) {
+            if (turn.userPrompt)
+                totalUserTurns++;
+            totalToolCalls += turn.toolCalls.length;
+            totalSubagentCalls += turn.toolCalls.filter((tc) => tc.toolName === "Agent").length;
+        }
+        totalSubagentCalls += Object.keys(s.subagents).length;
+    }
+    const total = totalUserTurns + totalToolCalls + totalSubagentCalls || 1;
+    const subagentRatio = totalSubagentCalls / total;
+    const toolRatio = totalToolCalls / total;
+    if (subagentRatio > 0.15)
+        return "subagent-delegated";
+    if (toolRatio > 0.6)
+        return "tool-heavy";
+    return "user-driven";
+}
+export function buildTopicNodes(clusterMembers, sessions, tfidf, toolIdf) {
+    const topics = [];
+    for (let ci = 0; ci < clusterMembers.length; ci++) {
+        const members = clusterMembers[ci];
+        const memberSessions = members.map((idx) => sessions[idx]);
+        // Compute cluster centroid (TF-IDF text only, for keyword extraction)
+        const centroid = new Float64Array(tfidf.vocabulary.length);
+        for (const idx of members) {
+            const vec = tfidf.vectors.get(sessions[idx].sessionId);
+            if (vec) {
+                for (let k = 0; k < centroid.length; k++)
+                    centroid[k] += vec[k];
+            }
+        }
+        for (let k = 0; k < centroid.length; k++)
+            centroid[k] /= members.length;
+        // Top-5 keywords from centroid
+        const scored = tfidf.vocabulary.map((term, idx) => ({
+            term,
+            score: centroid[idx],
+        }));
+        scored.sort((a, b) => b.score - a.score);
+        const keywords = scored.slice(0, 5).map((s) => s.term);
+        // Dominant project
+        const projectCounts = new Map();
+        for (const s of memberSessions) {
+            projectCounts.set(s.projectDisplayName, (projectCounts.get(s.projectDisplayName) || 0) + 1);
+        }
+        const sortedProjects = [...projectCounts.entries()].sort((a, b) => b[1] - a[1]);
+        const dominantProject = sortedProjects[0]?.[0] ?? "";
+        const allProjects = [...new Set(memberSessions.map((s) => s.projectDisplayName))];
+        // Label: top 2-3 keywords + project
+        const labelKeywords = keywords.slice(0, 3).join(", ");
+        const projectSuffix = allProjects.length > 1
+            ? `(${allProjects.length} projects)`
+            : `(${dominantProject.split("/").pop() || dominantProject})`;
+        const label = `${labelKeywords} ${projectSuffix}`;
+        // Aggregate metadata
+        const sessionIds = memberSessions.map((s) => s.sessionId);
+        const totalDuration = memberSessions.reduce((sum, s) => sum + s.meta.durationMinutes, 0);
+        const totalToolCalls = memberSessions.reduce((sum, s) => {
+            return (sum +
+                Object.values(s.meta.toolBreakdown).reduce((a, b) => a + b, 0));
+        }, 0);
+        const dates = memberSessions
+            .map((s) => s.meta.createdAt)
+            .filter(Boolean)
+            .sort();
+        // New fields: prompts, tool signature, role classification
+        // L2 normalize centroid for prompt selection
+        let centroidNorm = 0;
+        for (let k = 0; k < centroid.length; k++)
+            centroidNorm += centroid[k] * centroid[k];
+        centroidNorm = Math.sqrt(centroidNorm);
+        const normalizedCentroid = new Float64Array(centroid.length);
+        if (centroidNorm > 0) {
+            for (let k = 0; k < centroid.length; k++)
+                normalizedCentroid[k] = centroid[k] / centroidNorm;
+        }
+        const representativePrompts = selectRepresentativePrompts(memberSessions, normalizedCentroid, tfidf);
+        const suggestedPrompt = generateSuggestedPrompt(memberSessions, keywords, toolIdf);
+        const toolSignature = computeToolSignature(memberSessions, toolIdf);
+        const dominantRole = classifyDominantRole(memberSessions);
+        topics.push({
+            id: `topic-${String(ci + 1).padStart(3, "0")}`,
+            label,
+            keywords,
+            project: dominantProject,
+            projects: allProjects,
+            sessionIds,
+            sessionCount: members.length,
+            totalDurationMinutes: Math.round(totalDuration),
+            totalToolCalls,
+            firstSeen: dates[0] || "",
+            lastSeen: dates[dates.length - 1] || "",
+            betweennessCentrality: 0, // computed later
+            degreeCentrality: 0, // computed later
+            communityId: -1, // computed later
+            representativePrompts,
+            suggestedPrompt,
+            toolSignature,
+            dominantRole,
+            reusabilityScore: { overall: 0, frequency: 0, timeCost: 0, crossProjectScore: 0, recency: 0 }, // computed later
+        });
+    }
+    return topics;
+}

package/dist-cli/knowledge-graph/types.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for semantic knowledge graph construction.
+ */
+export {};

package/dist-cli/knowledge-graph-builder.js

@@ -0,0 +1,27 @@
+/**
+ * knowledge-graph-builder.ts
+ *
+ * Barrel re-export for backward compatibility.
+ * Implementation is in ./knowledge-graph/ submodules.
+ */
+export { 
+// Main entry point
+buildSemanticKnowledgeGraph, 
+// Tokenizer
+tokenize, splitCamelCase, extractPathTokens, isNoiseToken, 
+// TF-IDF
+buildTfidf, 
+// Feature extraction
+buildToolIdf, buildStructuralVectors, 
+// SVD
+buildCombinedMatrix, truncatedSvd, interpretLatentDimensions, 
+// Similarity
+cosineSimilarity, cosineDistance, 
+// Clustering
+agglomerativeClusteringFromDistMatrix, findElbowThreshold, clusterWithThresholdFromDistMatrix, splitOversizedClusters, 
+// Topic nodes
+extractDominantAction, selectRepresentativePrompts, generateSuggestedPrompt, computeToolSignature, classifyDominantRole, buildTopicNodes, 
+// Edges
+buildTopicEdges, classifyEdge, findSharedKeywords, findCommonPathPrefix, 
+// Community
+louvainDetection, brandesBetweenness, } from "./knowledge-graph/index.js";

package/dist-cli/session-parser.js

@@ -0,0 +1,360 @@
+/**
+ * session-parser.ts
+ *
+ * Session discovery, JSONL parsing, turn building, and metadata extraction.
+ * Extracted from analyze-sessions.ts for testability and reuse.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as readline from "node:readline";
+import * as os from "node:os";
+// ─── Constants ──────────────────────────────────────────────────────────────
+export const THINKING_LIMIT = 5000;
+export const TOOL_RESULT_LIMIT = 2000;
+export const WRITE_CONTENT_PREVIEW = 500;
+export const FIRST_PROMPT_LIMIT = 200;
+// ─── Session Discovery ─────────────────────────────────────────────────────
+export function discoverSessions(sessionsDir) {
+    const sessions = [];
+    if (!fs.existsSync(sessionsDir)) {
+        console.error(`Sessions directory not found: ${sessionsDir}`);
+        return sessions;
+    }
+    const projectDirs = fs.readdirSync(sessionsDir, { withFileTypes: true });
+    for (const entry of projectDirs) {
+        if (!entry.isDirectory())
+            continue;
+        const projectPath = path.join(sessionsDir, entry.name);
+        // Find .jsonl files directly in the project directory (not in subdirs)
+        const files = fs.readdirSync(projectPath, { withFileTypes: true });
+        for (const file of files) {
+            if (!file.isFile() || !file.name.endsWith(".jsonl"))
+                continue;
+            const sessionId = file.name.replace(".jsonl", "");
+            const filePath = path.join(projectPath, file.name);
+            // Look for subagent files
+            const subagentDir = path.join(projectPath, sessionId, "subagents");
+            const subagentFiles = [];
+            if (fs.existsSync(subagentDir)) {
+                const subFiles = fs.readdirSync(subagentDir, { withFileTypes: true });
+                for (const sf of subFiles) {
+                    if (sf.isFile() && sf.name.endsWith(".jsonl")) {
+                        subagentFiles.push(path.join(subagentDir, sf.name));
+                    }
+                }
+            }
+            sessions.push({
+                filePath,
+                sessionId,
+                projectDir: entry.name,
+                projectDisplayName: inferProjectName(entry.name),
+                subagentFiles,
+            });
+        }
+    }
+    return sessions;
+}
+export function inferProjectName(dirName) {
+    // Directory names look like: -Users-kazuki-chigita-src-github-com-chigichan24-crune
+    // We want: chigichan24/crune (the last two meaningful segments)
+    const parts = dirName.split("-").filter(Boolean);
+    if (parts.length >= 2) {
+        // Try to find github-com pattern
+        const githubIdx = parts.indexOf("github");
+        if (githubIdx !== -1 && parts[githubIdx + 1] === "com" && parts.length > githubIdx + 3) {
+            return parts.slice(githubIdx + 2).join("/");
+        }
+        // Fallback: last two segments
+        return parts.slice(-2).join("/");
+    }
+    return dirName;
+}
+// ─── JSONL Parser + Turn Builder ────────────────────────────────────────────
+export async function parseJsonlFile(filePath) {
+    const lines = [];
+    const stream = fs.createReadStream(filePath, { encoding: "utf-8" });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            // Skip progress and queue-operation lines
+            if (parsed.type === "progress" || parsed.type === "queue-operation")
+                continue;
+            lines.push(parsed);
+        }
+        catch {
+            // Malformed JSON — skip and warn
+            console.error(`  [WARN] Malformed JSON line in ${path.basename(filePath)}`);
+        }
+    }
+    return lines;
+}
+export function truncate(text, limit) {
+    if (text.length <= limit)
+        return text;
+    return text.slice(0, limit) + "\u2026";
+}
+export function isRealUserMessage(line) {
+    if (line.type !== "user")
+        return false;
+    if (line.isMeta)
+        return false;
+    const content = line.message?.content;
+    if (typeof content === "string") {
+        if (content.includes("<command-name>"))
+            return false;
+        if (content.includes("<local-command-caveat>"))
+            return false;
+        if (content.includes("<local-command-stdout>"))
+            return false;
+        if (content.trim().length === 0)
+            return false;
+        return true;
+    }
+    // Array content — check if it's a tool_result (which is NOT a new user turn)
+    if (Array.isArray(content)) {
+        const hasToolResult = content.some((block) => block.type === "tool_result");
+        if (hasToolResult)
+            return false;
+        // It's a real user message with structured content
+        return true;
+    }
+    return false;
+}
+export function isToolResultMessage(line) {
+    if (line.type !== "user")
+        return false;
+    const content = line.message?.content;
+    if (!Array.isArray(content))
+        return false;
+    return content.some((block) => block.type === "tool_result");
+}
+export function extractUserPrompt(line) {
+    const content = line.message?.content;
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        const textBlocks = content.filter((b) => b.type === "text");
+        if (textBlocks.length > 0) {
+            return textBlocks.map((b) => b.text || "").join("\n");
+        }
+    }
+    return "";
+}
+export function buildTurns(lines) {
+    const turns = [];
+    let currentTurn = null;
+    let turnIndex = 0;
+    for (const line of lines) {
+        // Skip file-history-snapshot and system lines
+        if (line.type === "file-history-snapshot" || line.type === "system")
+            continue;
+        // Real user message -> start new turn
+        if (isRealUserMessage(line)) {
+            if (currentTurn) {
+                turns.push(currentTurn);
+            }
+            currentTurn = {
+                turnIndex: turnIndex++,
+                userPrompt: extractUserPrompt(line),
+                timestamp: line.timestamp || "",
+                assistantThinking: [],
+                assistantTexts: [],
+                toolCalls: [],
+                model: undefined,
+            };
+            continue;
+        }
+        // Tool result -> attach to current turn's matching tool call
+        if (isToolResultMessage(line) && currentTurn) {
+            const content = line.message?.content;
+            for (const block of content) {
+                if (block.type === "tool_result" && block.tool_use_id) {
+                    const matchingTool = currentTurn.toolCalls.find((tc) => tc.toolUseId === block.tool_use_id);
+                    if (matchingTool) {
+                        const resultText = typeof block.content === "string"
+                            ? block.content
+                            : Array.isArray(block.content)
+                                ? block.content
+                                    .map((c) => c.text || "")
+                                    .join("\n")
+                                : JSON.stringify(block.content || "");
+                        matchingTool.result = truncate(resultText, TOOL_RESULT_LIMIT);
+                    }
+                }
+            }
+            continue;
+        }
+        // Assistant message -> add to current turn
+        if (line.type === "assistant" && currentTurn) {
+            const content = line.message?.content;
+            const model = line.message?.model;
+            if (model && !currentTurn.model) {
+                currentTurn.model = model;
+            }
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (block.type === "thinking" && block.thinking) {
+                        currentTurn.assistantThinking.push(truncate(block.thinking, THINKING_LIMIT));
+                    }
+                    else if (block.type === "text" && block.text) {
+                        currentTurn.assistantTexts.push(block.text);
+                    }
+                    else if (block.type === "tool_use") {
+                        const input = { ...block.input };
+                        // Truncate Write.content
+                        if (block.name === "Write" &&
+                            typeof input.content === "string") {
+                            const fullLen = input.content.length;
+                            input.content =
+                                truncate(input.content, WRITE_CONTENT_PREVIEW);
+                            input.contentLength = fullLen;
+                        }
+                        currentTurn.toolCalls.push({
+                            toolUseId: block.id || "",
+                            toolName: block.name || "unknown",
+                            input,
+                            result: undefined,
+                        });
+                    }
+                }
+            }
+            continue;
+        }
+    }
+    // Push last turn
+    if (currentTurn) {
+        turns.push(currentTurn);
+    }
+    return turns;
+}
+// ─── Metadata Extraction ────────────────────────────────────────────────────
+export function extractMetadata(sessionFile, lines, turns) {
+    let cwd = "";
+    let gitBranch = "";
+    let version = "";
+    let slug = "";
+    let permissionMode = "";
+    let createdAt = "";
+    let lastActiveAt = "";
+    const toolBreakdown = {};
+    const modelsUsed = {};
+    const filesEdited = new Set();
+    for (const line of lines) {
+        // Extract metadata from any line that has these fields
+        if (line.cwd && !cwd)
+            cwd = line.cwd;
+        if (line.gitBranch && !gitBranch)
+            gitBranch = line.gitBranch;
+        if (line.version && !version)
+            version = line.version;
+        if (line.slug && !slug)
+            slug = line.slug;
+        if (line.permissionMode && !permissionMode)
+            permissionMode = line.permissionMode;
+        // Track timestamps
+        if (line.timestamp) {
+            if (!createdAt || line.timestamp < createdAt)
+                createdAt = line.timestamp;
+            if (!lastActiveAt || line.timestamp > lastActiveAt)
+                lastActiveAt = line.timestamp;
+        }
+        // Extract model usage from assistant messages
+        if (line.type === "assistant" && line.message?.model) {
+            const model = line.message.model;
+            modelsUsed[model] = (modelsUsed[model] || 0) + 1;
+        }
+    }
+    // Extract tool breakdown and files edited from turns
+    for (const turn of turns) {
+        for (const tc of turn.toolCalls) {
+            toolBreakdown[tc.toolName] = (toolBreakdown[tc.toolName] || 0) + 1;
+            // Track files edited via Edit/Write
+            if (tc.toolName === "Edit" || tc.toolName === "Write") {
+                const fp = tc.input.file_path;
+                if (typeof fp === "string") {
+                    filesEdited.add(fp);
+                }
+            }
+        }
+    }
+    const durationMinutes = createdAt && lastActiveAt
+        ? Math.round((new Date(lastActiveAt).getTime() - new Date(createdAt).getTime()) /
+            60000)
+        : 0;
+    const firstPrompt = turns.length > 0 ? turns[0].userPrompt : "";
+    return {
+        sessionId: sessionFile.sessionId,
+        cwd,
+        gitBranch,
+        version,
+        slug,
+        createdAt,
+        lastActiveAt,
+        durationMinutes,
+        permissionMode,
+        toolBreakdown,
+        modelsUsed,
+        filesEdited: [...filesEdited],
+        subagentCount: sessionFile.subagentFiles.length,
+        turnCount: turns.length,
+        firstUserPrompt: truncate(firstPrompt, FIRST_PROMPT_LIMIT),
+    };
+}
+// ─── Subagent Linking ───────────────────────────────────────────────────────
+export async function parseSubagents(subagentFiles) {
+    const subagents = {};
+    for (const filePath of subagentFiles) {
+        const basename = path.basename(filePath, ".jsonl");
+        // agent-a8edec15cbcf8cf42.jsonl -> agentId = a8edec15cbcf8cf42
+        const agentId = basename.replace("agent-", "");
+        // Read meta.json if exists
+        const metaPath = filePath.replace(".jsonl", ".meta.json");
+        let agentType = "unknown";
+        if (fs.existsSync(metaPath)) {
+            try {
+                const metaContent = fs.readFileSync(metaPath, "utf-8");
+                const meta = JSON.parse(metaContent);
+                agentType = meta.agentType || "unknown";
+            }
+            catch {
+                // ignore
+            }
+        }
+        const lines = await parseJsonlFile(filePath);
+        const turns = buildTurns(lines);
+        // Extract model from first assistant line
+        let model;
+        for (const line of lines) {
+            if (line.type === "assistant" && line.message?.model) {
+                model = line.message.model;
+                break;
+            }
+        }
+        subagents[agentId] = {
+            agentId,
+            agentType,
+            turns,
+            model,
+        };
+    }
+    return subagents;
+}
+// ─── Linked Plan ────────────────────────────────────────────────────────────
+export function loadLinkedPlan(slug) {
+    if (!slug)
+        return null;
+    const planPath = path.join(os.homedir(), ".claude", "plans", `${slug}.md`);
+    if (fs.existsSync(planPath)) {
+        try {
+            const content = fs.readFileSync(planPath, "utf-8");
+            return { slug, content };
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}