@chigichan24/crune 0.1.0

package/dist-cli/__tests__/community.test.js

@@ -0,0 +1,115 @@
+import { describe, it, expect } from "vitest";
+import { louvainDetection, brandesBetweenness } from "../knowledge-graph-builder.js";
+function makeTopicNode(id, project = "default-project") {
+    return {
+        id,
+        label: `Topic ${id}`,
+        keywords: [],
+        project,
+        projects: [project],
+        sessionIds: [],
+        sessionCount: 0,
+        totalDurationMinutes: 0,
+        totalToolCalls: 0,
+        firstSeen: "2025-01-01T00:00:00Z",
+        lastSeen: "2025-01-01T00:00:00Z",
+        betweennessCentrality: 0,
+        degreeCentrality: 0,
+        communityId: -1,
+        representativePrompts: [],
+        suggestedPrompt: "",
+        toolSignature: [],
+        dominantRole: "user-driven",
+        reusabilityScore: { overall: 0, frequency: 0, timeCost: 0, crossProjectScore: 0, recency: 0 },
+    };
+}
+function makeTopicEdge(source, target, strength = 1.0) {
+    return {
+        source,
+        target,
+        type: "semantic-similarity",
+        strength,
+        label: `${source}-${target}`,
+        signals: {
+            semanticSimilarity: strength,
+            fileOverlap: 0,
+            sessionOverlap: 0,
+        },
+    };
+}
+describe("louvainDetection", () => {
+    it("returns empty communities and modularity 0 for 0 topics", () => {
+        const result = louvainDetection([], []);
+        expect(result).toEqual({ communities: [], modularity: 0 });
+    });
+    it("assigns each isolated topic its own community when there are no edges", () => {
+        const topics = [makeTopicNode("A"), makeTopicNode("B"), makeTopicNode("C")];
+        const result = louvainDetection(topics, []);
+        expect(result.communities).toHaveLength(3);
+        // Each community should contain exactly one topic
+        const allTopicIds = result.communities.flatMap((c) => c.topicIds);
+        expect(allTopicIds.sort()).toEqual(["A", "B", "C"]);
+        for (const community of result.communities) {
+            expect(community.topicIds).toHaveLength(1);
+        }
+        // When there are no edges (totalWeight === 0), the function returns
+        // individual communities but does not mutate topics[i].communityId.
+        // Verify via the returned communities structure instead.
+        expect(result.modularity).toBe(0);
+        for (const community of result.communities) {
+            expect(community).toHaveProperty("id");
+            expect(community).toHaveProperty("topicIds");
+        }
+    });
+    it("detects 2 communities for 2 disconnected pairs", () => {
+        const topics = [
+            makeTopicNode("A"),
+            makeTopicNode("B"),
+            makeTopicNode("C"),
+            makeTopicNode("D"),
+        ];
+        const edges = [makeTopicEdge("A", "B"), makeTopicEdge("C", "D")];
+        const result = louvainDetection(topics, edges);
+        expect(result.communities).toHaveLength(2);
+        // A and B should be in the same community
+        const communityOfA = topics.find((t) => t.id === "A").communityId;
+        const communityOfB = topics.find((t) => t.id === "B").communityId;
+        const communityOfC = topics.find((t) => t.id === "C").communityId;
+        const communityOfD = topics.find((t) => t.id === "D").communityId;
+        expect(communityOfA).toBe(communityOfB);
+        expect(communityOfC).toBe(communityOfD);
+        expect(communityOfA).not.toBe(communityOfC);
+    });
+});
+describe("brandesBetweenness", () => {
+    it("does not crash and keeps centralities at 0 when n <= 2", () => {
+        const topics = [makeTopicNode("A"), makeTopicNode("B")];
+        const edges = [makeTopicEdge("A", "B")];
+        brandesBetweenness(topics, edges);
+        expect(topics[0].betweennessCentrality).toBe(0);
+        expect(topics[1].betweennessCentrality).toBe(0);
+    });
+    it("gives highest betweenness to the middle node in a linear graph A-B-C", () => {
+        const topics = [makeTopicNode("A"), makeTopicNode("B"), makeTopicNode("C")];
+        const edges = [makeTopicEdge("A", "B"), makeTopicEdge("B", "C")];
+        brandesBetweenness(topics, edges);
+        const bcA = topics.find((t) => t.id === "A").betweennessCentrality;
+        const bcB = topics.find((t) => t.id === "B").betweennessCentrality;
+        const bcC = topics.find((t) => t.id === "C").betweennessCentrality;
+        expect(bcB).toBeGreaterThan(bcA);
+        expect(bcB).toBeGreaterThan(bcC);
+    });
+    it("sets degree centrality correctly for a linear graph A-B-C", () => {
+        const topics = [makeTopicNode("A"), makeTopicNode("B"), makeTopicNode("C")];
+        const edges = [makeTopicEdge("A", "B"), makeTopicEdge("B", "C")];
+        brandesBetweenness(topics, edges);
+        const dcA = topics.find((t) => t.id === "A").degreeCentrality;
+        const dcB = topics.find((t) => t.id === "B").degreeCentrality;
+        const dcC = topics.find((t) => t.id === "C").degreeCentrality;
+        // B has degree 2, normalized: 2 / (3 - 1) = 1.0
+        expect(dcB).toBeCloseTo(1.0);
+        // A and C have degree 1, normalized: 1 / (3 - 1) = 0.5
+        expect(dcA).toBeCloseTo(0.5);
+        expect(dcC).toBeCloseTo(0.5);
+    });
+});

package/dist-cli/__tests__/edges.test.js

@@ -0,0 +1,130 @@
+import { describe, it, expect } from "vitest";
+import { findCommonPathPrefix, findSharedKeywords, classifyEdge, } from "../knowledge-graph-builder.js";
+function makeTopicNode(overrides = {}) {
+    return {
+        id: "topic-1",
+        label: "test topic",
+        keywords: [],
+        project: "projectA",
+        projects: ["projectA"],
+        sessionIds: ["s1"],
+        sessionCount: 1,
+        totalDurationMinutes: 10,
+        totalToolCalls: 5,
+        firstSeen: "2025-01-01",
+        lastSeen: "2025-01-02",
+        betweennessCentrality: 0,
+        degreeCentrality: 0,
+        communityId: 0,
+        representativePrompts: [],
+        suggestedPrompt: "",
+        toolSignature: [],
+        dominantRole: "user-driven",
+        reusabilityScore: { overall: 0, frequency: 0, timeCost: 0, crossProjectScore: 0, recency: 0 },
+        ...overrides,
+    };
+}
+function makeTfidf(vocabulary, vectors) {
+    const vocabIndex = new Map();
+    vocabulary.forEach((v, i) => vocabIndex.set(v, i));
+    return { vocabulary, vocabIndex, vectors };
+}
+describe("findCommonPathPrefix", () => {
+    it("returns common prefix for paths sharing a directory", () => {
+        expect(findCommonPathPrefix(["/src/a/b.ts", "/src/a/c.ts"])).toBe("/src/a");
+    });
+    it("returns empty string when prefix is too short (<=1 segment)", () => {
+        expect(findCommonPathPrefix(["/a/b", "/c/d"])).toBe("");
+    });
+    it("returns empty string for empty input", () => {
+        expect(findCommonPathPrefix([])).toBe("");
+    });
+});
+describe("findSharedKeywords", () => {
+    it("returns terms with high weight in both centroids", () => {
+        const vocabulary = ["react", "typescript", "testing", "css"];
+        const centroids = new Map([
+            ["t1", new Float64Array([0.5, 0.8, 0.02, 0.001])],
+            ["t2", new Float64Array([0.3, 0.6, 0.9, 0.005])],
+        ]);
+        const tfidf = makeTfidf(vocabulary, new Map());
+        const shared = findSharedKeywords("t1", "t2", tfidf, centroids, 3);
+        // "react" (0.5 > 0.01 & 0.3 > 0.01) and "typescript" (0.8 > 0.01 & 0.6 > 0.01)
+        // "testing" only in t1 is 0.02 and t2 is 0.9, both > 0.01 → included
+        // "css" is below 0.01 in both → excluded
+        expect(shared).toContain("react");
+        expect(shared).toContain("typescript");
+        expect(shared).toContain("testing");
+        expect(shared).not.toContain("css");
+    });
+    it("returns empty array when one centroid is missing", () => {
+        const tfidf = makeTfidf(["a"], new Map());
+        const centroids = new Map([
+            ["t1", new Float64Array([0.5])],
+        ]);
+        expect(findSharedKeywords("t1", "t_missing", tfidf, centroids, 3)).toEqual([]);
+    });
+});
+describe("classifyEdge", () => {
+    it("returns cross-project-bridge when topics are from different projects with no overlap", () => {
+        const ti = makeTopicNode({
+            id: "t1",
+            project: "projectA",
+            projects: ["projectA"],
+        });
+        const tj = makeTopicNode({
+            id: "t2",
+            project: "projectB",
+            projects: ["projectB"],
+        });
+        const signals = { semanticSimilarity: 0.5, fileOverlap: 0.1, sessionOverlap: 0.1 };
+        const tfidf = makeTfidf(["shared"], new Map());
+        const centroids = new Map([
+            ["t1", new Float64Array([0.5])],
+            ["t2", new Float64Array([0.5])],
+        ]);
+        const result = classifyEdge(ti, tj, signals, [], tfidf, centroids);
+        expect(result.type).toBe("cross-project-bridge");
+        expect(result.label).toContain("cross-project");
+    });
+    it("returns shared-module when fileOverlap is the dominant signal and shared files exist", () => {
+        const ti = makeTopicNode({
+            id: "t1",
+            project: "projectA",
+            projects: ["projectA"],
+        });
+        const tj = makeTopicNode({
+            id: "t2",
+            project: "projectA",
+            projects: ["projectA"],
+        });
+        // fileOverlap * 0.3 must be the max signal
+        // semanticSimilarity * 0.4 < fileOverlap * 0.3 → need fileOverlap high, semantic low
+        const signals = { semanticSimilarity: 0.1, fileOverlap: 0.9, sessionOverlap: 0.0 };
+        const sharedFiles = ["/src/components/Button.tsx", "/src/components/Card.tsx"];
+        const tfidf = makeTfidf([], new Map());
+        const centroids = new Map();
+        const result = classifyEdge(ti, tj, signals, sharedFiles, tfidf, centroids);
+        expect(result.type).toBe("shared-module");
+        expect(result.label).toContain("shared");
+    });
+    it("returns workflow-continuation when sessionOverlap is the dominant signal", () => {
+        const ti = makeTopicNode({
+            id: "t1",
+            project: "projectA",
+            projects: ["projectA"],
+        });
+        const tj = makeTopicNode({
+            id: "t2",
+            project: "projectA",
+            projects: ["projectA"],
+        });
+        // sessionOverlap * 0.3 must be the max, fileOverlap * 0.3 must be less or no shared files
+        const signals = { semanticSimilarity: 0.1, fileOverlap: 0.0, sessionOverlap: 0.9 };
+        const tfidf = makeTfidf([], new Map());
+        const centroids = new Map();
+        const result = classifyEdge(ti, tj, signals, [], tfidf, centroids);
+        expect(result.type).toBe("workflow-continuation");
+        expect(result.label).toBe("workflow continuation");
+    });
+});

package/dist-cli/__tests__/feature-extraction.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "vitest";
+import { buildToolIdf, buildStructuralVectors } from "../knowledge-graph-builder.js";
+import { editHeavySession, readHeavySession, subagentSession, emptySession, allSessions } from "./fixtures.js";
+describe("buildToolIdf", () => {
+    it("gives tool in 1 of 3 sessions higher IDF than tool in all 3", () => {
+        // Use editHeavy, readHeavy, subagent sessions
+        const sessions = [editHeavySession, readHeavySession, subagentSession];
+        const result = buildToolIdf(sessions);
+        // "Edit" appears in editHeavy (10) and readHeavy (1) => df=2
+        // "Bash" appears in subagent only => df=1
+        // "Glob" appears in readHeavy only => df=1
+        // "Read" appears in editHeavy (1) and readHeavy (15) => df=2
+        // All tools appear, but tools in fewer sessions get higher IDF
+        // IDF = log(n/df): log(3/1) > log(3/2)
+        const idfBash = result.toolIdfWeights.get("Bash"); // df=1
+        const idfEdit = result.toolIdfWeights.get("Edit"); // df=2
+        expect(idfBash).toBeGreaterThan(idfEdit);
+    });
+    it("produces L2-normalized vectors", () => {
+        const sessions = [editHeavySession, readHeavySession, subagentSession];
+        const result = buildToolIdf(sessions);
+        for (const [, vec] of result.vectors) {
+            let dotProduct = 0;
+            for (let i = 0; i < vec.length; i++) {
+                dotProduct += vec[i] * vec[i];
+            }
+            if (dotProduct > 0) {
+                expect(dotProduct).toBeCloseTo(1.0, 10);
+            }
+        }
+    });
+});
+describe("buildStructuralVectors", () => {
+    it("returns zero vector for session with 0 turns", () => {
+        const vectors = buildStructuralVectors([emptySession]);
+        const vec = vectors.get("empty");
+        expect(vec.length).toBe(7);
+        for (let i = 0; i < vec.length; i++) {
+            expect(vec[i]).toBe(0);
+        }
+    });
+    it("edit-heavy session has editHeaviness > readHeaviness", () => {
+        const vectors = buildStructuralVectors(allSessions);
+        const vec = vectors.get("edit-heavy");
+        // vec[5] = editHeaviness, vec[6] = readHeaviness (before normalization ratios preserved)
+        expect(vec[5]).toBeGreaterThan(vec[6]);
+    });
+    it("read-heavy session has readHeaviness > editHeaviness", () => {
+        const vectors = buildStructuralVectors(allSessions);
+        const vec = vectors.get("read-heavy");
+        // vec[6] = readHeaviness, vec[5] = editHeaviness
+        expect(vec[6]).toBeGreaterThan(vec[5]);
+    });
+    it("produces L2-normalized vectors for non-empty sessions", () => {
+        const vectors = buildStructuralVectors(allSessions);
+        for (const [sessionId, vec] of vectors) {
+            if (sessionId === "empty")
+                continue; // zero vector, skip
+            let dotProduct = 0;
+            for (let i = 0; i < vec.length; i++) {
+                dotProduct += vec[i] * vec[i];
+            }
+            expect(dotProduct).toBeCloseTo(1.0, 10);
+        }
+    });
+});

package/dist-cli/__tests__/fixtures.js

@@ -0,0 +1,192 @@
+export function makeSession(overrides) {
+    return {
+        sessionId: overrides.sessionId,
+        projectDisplayName: overrides.projectDisplayName ?? "test-project",
+        turns: overrides.turns ?? [],
+        subagents: overrides.subagents ?? {},
+        meta: {
+            sessionId: overrides.sessionId,
+            createdAt: "2025-01-01T00:00:00Z",
+            lastActiveAt: "2025-01-01T01:00:00Z",
+            durationMinutes: 60,
+            filesEdited: [],
+            gitBranch: "main",
+            toolBreakdown: {},
+            subagentCount: 0,
+            ...overrides.meta,
+        },
+    };
+}
+/** Session with edit-heavy tool usage */
+export const editHeavySession = makeSession({
+    sessionId: "edit-heavy",
+    projectDisplayName: "crune",
+    turns: [
+        {
+            userPrompt: "Fix the camelCase parser bug in /src/utils/tokenizer.ts",
+            assistantTexts: ["I'll fix the tokenizer bug"],
+            toolCalls: [
+                { toolName: "Read", input: { file: "/src/utils/tokenizer.ts" } },
+                { toolName: "Edit", input: { file: "/src/utils/tokenizer.ts" } },
+                { toolName: "Edit", input: { file: "/src/utils/tokenizer.ts" } },
+            ],
+        },
+        {
+            userPrompt: "Also update the tests",
+            assistantTexts: ["Updated the tests"],
+            toolCalls: [
+                { toolName: "Read", input: { file: "/src/utils/tokenizer.test.ts" } },
+                { toolName: "Write", input: { file: "/src/utils/tokenizer.test.ts" } },
+            ],
+        },
+    ],
+    subagents: {},
+    meta: {
+        sessionId: "edit-heavy",
+        createdAt: "2025-01-01T10:00:00Z",
+        lastActiveAt: "2025-01-01T11:00:00Z",
+        durationMinutes: 60,
+        filesEdited: ["/src/utils/tokenizer.ts", "/src/utils/tokenizer.test.ts"],
+        gitBranch: "fix/tokenizer",
+        toolBreakdown: { Read: 2, Edit: 2, Write: 1 },
+        subagentCount: 0,
+    },
+});
+/** Session with read-heavy tool usage */
+export const readHeavySession = makeSession({
+    sessionId: "read-heavy",
+    projectDisplayName: "crune",
+    turns: [
+        {
+            userPrompt: "Investigate the logging setup in /src/components/App.tsx",
+            assistantTexts: ["Let me look at the logging setup"],
+            toolCalls: [
+                { toolName: "Grep", input: { pattern: "console.log" } },
+                { toolName: "Read", input: { file: "/src/components/App.tsx" } },
+                { toolName: "Glob", input: { pattern: "*.log" } },
+                { toolName: "Read", input: { file: "/src/config/logging.ts" } },
+            ],
+        },
+    ],
+    subagents: {},
+    meta: {
+        sessionId: "read-heavy",
+        createdAt: "2025-01-02T10:00:00Z",
+        lastActiveAt: "2025-01-02T10:30:00Z",
+        durationMinutes: 30,
+        filesEdited: [],
+        gitBranch: "main",
+        toolBreakdown: { Read: 2, Grep: 1, Glob: 1 },
+        subagentCount: 0,
+    },
+});
+/** Session with subagent delegation */
+export const subagentSession = makeSession({
+    sessionId: "subagent-heavy",
+    projectDisplayName: "other-project",
+    turns: [
+        {
+            userPrompt: "Refactor the authentication module in /src/auth/handler.ts",
+            assistantTexts: ["I'll delegate this to subagents"],
+            toolCalls: [
+                { toolName: "Agent", input: { task: "refactor auth" } },
+                { toolName: "Agent", input: { task: "update tests" } },
+            ],
+        },
+        {
+            userPrompt: "Deploy the changes",
+            assistantTexts: ["Deploying now"],
+            toolCalls: [
+                { toolName: "Bash", input: { command: "npm run deploy" } },
+            ],
+        },
+    ],
+    subagents: {
+        "agent-1": {
+            agentId: "agent-1",
+            agentType: "code",
+            turns: [
+                {
+                    userPrompt: "refactor auth",
+                    assistantTexts: ["Done"],
+                    toolCalls: [
+                        { toolName: "Edit", input: { file: "/src/auth/handler.ts" } },
+                    ],
+                },
+            ],
+        },
+        "agent-2": {
+            agentId: "agent-2",
+            agentType: "test",
+            turns: [
+                {
+                    userPrompt: "update tests",
+                    assistantTexts: ["Tests updated"],
+                    toolCalls: [
+                        { toolName: "Write", input: { file: "/src/auth/handler.test.ts" } },
+                    ],
+                },
+            ],
+        },
+    },
+    meta: {
+        sessionId: "subagent-heavy",
+        createdAt: "2025-01-03T10:00:00Z",
+        lastActiveAt: "2025-01-03T11:30:00Z",
+        durationMinutes: 90,
+        filesEdited: ["/src/auth/handler.ts", "/src/auth/handler.test.ts"],
+        gitBranch: "refactor/auth",
+        toolBreakdown: { Agent: 2, Bash: 1, Edit: 1, Write: 1 },
+        subagentCount: 2,
+    },
+});
+/** Session with Japanese prompts */
+export const japaneseSession = makeSession({
+    sessionId: "japanese",
+    projectDisplayName: "crune",
+    turns: [
+        {
+            userPrompt: "修正してください: /src/components/Overview.tsx のバグ",
+            assistantTexts: ["バグを修正します"],
+            toolCalls: [
+                { toolName: "Read", input: { file: "/src/components/Overview.tsx" } },
+                { toolName: "Edit", input: { file: "/src/components/Overview.tsx" } },
+            ],
+        },
+    ],
+    subagents: {},
+    meta: {
+        sessionId: "japanese",
+        createdAt: "2025-01-01T12:00:00Z",
+        lastActiveAt: "2025-01-01T12:30:00Z",
+        durationMinutes: 30,
+        filesEdited: ["/src/components/Overview.tsx"],
+        gitBranch: "fix/overview",
+        toolBreakdown: { Read: 1, Edit: 1 },
+        subagentCount: 0,
+    },
+});
+/** Minimal empty session */
+export const emptySession = makeSession({
+    sessionId: "empty",
+    projectDisplayName: "crune",
+    turns: [],
+    meta: {
+        sessionId: "empty",
+        createdAt: "2025-01-05T00:00:00Z",
+        lastActiveAt: "2025-01-05T00:00:00Z",
+        durationMinutes: 0,
+        filesEdited: [],
+        gitBranch: "",
+        toolBreakdown: {},
+        subagentCount: 0,
+    },
+});
+/** All fixture sessions */
+export const allSessions = [
+    editHeavySession,
+    readHeavySession,
+    subagentSession,
+    japaneseSession,
+    emptySession,
+];