@chigichan24/crune 0.1.0

package/dist-cli/cli.js

@@ -0,0 +1,215 @@
+/**
+ * CLI entry point for `npx @chigichan24/crune`
+ * Generates skill definitions from Claude Code session logs.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { discoverSessions, parseJsonlFile, buildTurns, extractMetadata, parseSubagents, } from "./session-parser.js";
+import { buildSemanticKnowledgeGraph, } from "./knowledge-graph-builder.js";
+import { buildSynthesisPrompt, synthesizeWithClaude, } from "./skill-synthesizer.js";
+export function parseCliArgs(argv) {
+    const args = argv.slice(2);
+    let sessionsDir = path.join(os.homedir(), ".claude", "projects");
+    let outputDir = path.resolve("skills");
+    let count = 5;
+    let model;
+    let skipSynthesis = false;
+    let dryRun = false;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--sessions-dir" && args[i + 1]) {
+            sessionsDir = path.resolve(args[++i]);
+        }
+        else if (args[i] === "--output-dir" && args[i + 1]) {
+            outputDir = path.resolve(args[++i]);
+        }
+        else if (args[i] === "--count" && args[i + 1]) {
+            const parsed = parseInt(args[++i], 10);
+            count = Math.max(1, Number.isNaN(parsed) ? 5 : parsed);
+        }
+        else if (args[i] === "--model" && args[i + 1]) {
+            model = args[++i];
+        }
+        else if (args[i] === "--skip-synthesis") {
+            skipSynthesis = true;
+        }
+        else if (args[i] === "--dry-run") {
+            dryRun = true;
+        }
+        else if (args[i] === "--help" || args[i] === "-h") {
+            printUsage();
+            process.exit(0);
+        }
+    }
+    return { sessionsDir, outputDir, count, model, skipSynthesis, dryRun };
+}
+function printUsage() {
+    console.error(`Usage: crune [options]
+
+Generate reusable skill definitions from Claude Code session logs.
+
+Options:
+  --sessions-dir <path>  Session logs directory (default: ~/.claude/projects)
+  --output-dir <path>    Output directory for skill files (default: ./skills)
+  --count <n>            Number of skills to generate (default: 5)
+  --model <model>        Claude model for synthesis (e.g., haiku, sonnet)
+  --skip-synthesis       Skip LLM synthesis, output heuristic skills only
+  --dry-run              Show candidates without writing files
+  -h, --help             Show this help message`);
+}
+// ─── Main pipeline ─────────────────────────────────────────────────
+async function main() {
+    const config = parseCliArgs(process.argv);
+    console.error("Discovering sessions...");
+    const sessionFiles = discoverSessions(config.sessionsDir);
+    if (sessionFiles.length === 0) {
+        console.error(`No sessions found in ${config.sessionsDir}`);
+        process.exit(1);
+    }
+    console.error(`  Found ${sessionFiles.length} sessions`);
+    // Parse all sessions
+    console.error("Parsing sessions...");
+    const parsedSessions = [];
+    for (const sf of sessionFiles) {
+        const lines = await parseJsonlFile(sf.filePath);
+        if (lines.length === 0)
+            continue;
+        const turns = buildTurns(lines);
+        const meta = extractMetadata(sf, lines, turns);
+        const subagents = await parseSubagents(sf.subagentFiles);
+        parsedSessions.push({
+            meta,
+            turns,
+            subagents,
+            linkedPlan: null,
+            projectDir: sf.projectDir,
+            projectDisplayName: sf.projectDisplayName,
+        });
+    }
+    console.error(`  Parsed ${parsedSessions.length} sessions`);
+    // Build knowledge graph — reuse same conversion as analyze-sessions.ts
+    console.error("Building knowledge graph...");
+    const sessionInputs = parsedSessions.map((s) => ({
+        sessionId: s.meta.sessionId,
+        projectDisplayName: s.projectDisplayName,
+        turns: s.turns.map((t) => ({
+            userPrompt: t.userPrompt,
+            assistantTexts: t.assistantTexts,
+            toolCalls: t.toolCalls.map((tc) => ({
+                toolName: tc.toolName,
+                input: tc.input,
+            })),
+        })),
+        subagents: Object.fromEntries(Object.entries(s.subagents).map(([id, sub]) => [
+            id,
+            {
+                agentId: sub.agentId,
+                agentType: sub.agentType,
+                turns: sub.turns.map((t) => ({
+                    userPrompt: t.userPrompt,
+                    assistantTexts: t.assistantTexts,
+                    toolCalls: t.toolCalls.map((tc) => ({
+                        toolName: tc.toolName,
+                        input: tc.input,
+                    })),
+                })),
+            },
+        ])),
+        meta: {
+            sessionId: s.meta.sessionId,
+            createdAt: s.meta.createdAt,
+            lastActiveAt: s.meta.lastActiveAt,
+            durationMinutes: s.meta.durationMinutes,
+            filesEdited: s.meta.filesEdited,
+            gitBranch: s.meta.gitBranch,
+            toolBreakdown: s.meta.toolBreakdown,
+            subagentCount: s.meta.subagentCount,
+        },
+    }));
+    const knowledgeGraph = buildSemanticKnowledgeGraph(sessionInputs);
+    console.error(`  ${knowledgeGraph.nodes.length} topics, ${knowledgeGraph.skillCandidates.length} skill candidates`);
+    // Select top candidates
+    const topCandidates = [...knowledgeGraph.skillCandidates]
+        .sort((a, b) => b.reusabilityScore - a.reusabilityScore)
+        .slice(0, config.count);
+    if (topCandidates.length === 0) {
+        console.error("No skill candidates found.");
+        process.exit(0);
+    }
+    // Dry run — just list candidates
+    if (config.dryRun) {
+        console.error("\nSkill candidates (dry run):\n");
+        for (const c of topCandidates) {
+            const topic = knowledgeGraph.nodes.find((n) => n.id === c.topicId);
+            console.error(`  [${c.reusabilityScore.toFixed(2)}] ${topic?.label ?? c.topicId}`);
+            console.error(`    Keywords: ${topic?.keywords.join(", ") ?? "—"}`);
+            console.error(`    Sessions: ${topic?.sessionCount ?? "?"}`);
+            console.error("");
+        }
+        process.exit(0);
+    }
+    // Synthesize skills
+    console.error(`\nGenerating ${topCandidates.length} skills...`);
+    for (const candidate of topCandidates) {
+        const topic = knowledgeGraph.nodes.find((n) => n.id === candidate.topicId);
+        const label = topic?.label ?? candidate.topicId;
+        console.error(`  -> ${label}`);
+        let markdown = candidate.skillMarkdown;
+        if (!config.skipSynthesis && topic) {
+            // Find enriched sequences related to this topic's sessions
+            const topicSessionSet = new Set(topic.sessionIds);
+            const relatedSequences = knowledgeGraph.enrichedToolSequences.filter((seq) => seq.sessionIds.some((sid) => topicSessionSet.has(sid)));
+            const prompt = buildSynthesisPrompt({
+                skillCandidate: candidate,
+                topicNode: topic,
+                enrichedSequences: relatedSequences,
+            });
+            const result = await synthesizeWithClaude(prompt, {
+                model: config.model,
+            });
+            if (result.success) {
+                markdown = result.stdout;
+                console.error(`    Synthesized`);
+            }
+            else {
+                console.error(`    Synthesis failed: ${result.error ?? "unknown error"}, using heuristic`);
+            }
+        }
+        else if (config.skipSynthesis) {
+            console.error(`    Heuristic only`);
+        }
+        // Write skill file as <output-dir>/<skill-name>/SKILL.md
+        const skillName = extractSkillName(markdown, label);
+        const skillDir = path.join(config.outputDir, skillName);
+        const outputPath = path.join(skillDir, "SKILL.md");
+        fs.mkdirSync(skillDir, { recursive: true });
+        fs.writeFileSync(outputPath, markdown, "utf-8");
+        console.error(`    ${outputPath}`);
+    }
+    console.error(`\nDone! ${topCandidates.length} skills written to ${config.outputDir}`);
+}
+function extractSkillName(markdown, fallbackLabel) {
+    // Try to extract name from YAML frontmatter
+    const frontmatterMatch = markdown.match(/^---\s*\n[\s\S]*?name:\s*(.+?)\s*\n[\s\S]*?---/);
+    if (frontmatterMatch?.[1]) {
+        return frontmatterMatch[1].replace(/[^a-zA-Z0-9-_]/g, "-").toLowerCase();
+    }
+    // Fallback: kebab-case from label
+    return fallbackLabel
+        .replace(/[^a-zA-Z0-9\s-]/g, "")
+        .trim()
+        .replace(/\s+/g, "-")
+        .toLowerCase()
+        .slice(0, 40);
+}
+// ─── Entry point ───────────────────────────────────────────────────
+const entryScript = process.argv[1] ?? "";
+const isDirectRun = entryScript.endsWith("/cli.ts") ||
+    entryScript.endsWith("/cli.js") ||
+    entryScript.endsWith("/bin/crune.js");
+if (isDirectRun) {
+    main().catch((err) => {
+        console.error("Fatal error:", err);
+        process.exit(1);
+    });
+}

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

@@ -0,0 +1,174 @@
+/**
+ * Agglomerative clustering with average linkage and automatic elbow detection.
+ */
+export function agglomerativeClusteringFromDistMatrix(sessionIds, precomputedDist) {
+    const n = sessionIds.length;
+    if (n === 0)
+        return [];
+    if (n === 1)
+        return [[0]];
+    // Initialize: each session is its own cluster
+    const clusterMembers = [];
+    for (let i = 0; i < n; i++)
+        clusterMembers.push([i]);
+    // Track active clusters
+    const active = new Set();
+    for (let i = 0; i < n; i++)
+        active.add(i);
+    // Copy precomputed distances (will be updated during merges)
+    const distMatrix = new Map(precomputedDist);
+    const distKey = (i, j) => i < j ? `${i}:${j}` : `${j}:${i}`;
+    // Merge history for elbow detection
+    const mergeDistances = [];
+    // Iteratively merge closest pair
+    while (active.size > 1) {
+        let minDist = Infinity;
+        let mergeI = -1;
+        let mergeJ = -1;
+        for (const i of active) {
+            for (const j of active) {
+                if (i >= j)
+                    continue;
+                const d = distMatrix.get(distKey(i, j)) ?? Infinity;
+                if (d < minDist) {
+                    minDist = d;
+                    mergeI = i;
+                    mergeJ = j;
+                }
+            }
+        }
+        if (mergeI === -1)
+            break;
+        mergeDistances.push(minDist);
+        // Merge j into i (average linkage: weighted average of distances)
+        const sizeI = clusterMembers[mergeI].length;
+        const sizeJ = clusterMembers[mergeJ].length;
+        const newSize = sizeI + sizeJ;
+        clusterMembers[mergeI].push(...clusterMembers[mergeJ]);
+        active.delete(mergeJ);
+        // Update distances using average linkage formula
+        for (const k of active) {
+            if (k === mergeI)
+                continue;
+            const distIK = distMatrix.get(distKey(mergeI, k)) ?? 1.0;
+            const distJK = distMatrix.get(distKey(mergeJ, k)) ?? 1.0;
+            const newDist = (distIK * sizeI + distJK * sizeJ) / newSize;
+            distMatrix.set(distKey(mergeI, k), newDist);
+        }
+    }
+    // Find elbow: cut point where merging starts getting expensive
+    const threshold = findElbowThreshold(mergeDistances);
+    // Re-run clustering with threshold using precomputed distances
+    return clusterWithThresholdFromDistMatrix(n, precomputedDist, threshold);
+}
+export function findElbowThreshold(distances) {
+    if (distances.length < 3)
+        return 0.7; // fallback
+    // Compute second derivative (acceleration)
+    let maxAccel = 0;
+    let elbowIdx = Math.floor(distances.length * 0.5); // default: cut at midpoint
+    for (let i = 1; i < distances.length - 1; i++) {
+        const accel = distances[i + 1] - 2 * distances[i] + distances[i - 1];
+        if (accel > maxAccel) {
+            maxAccel = accel;
+            elbowIdx = i;
+        }
+    }
+    const threshold = distances[elbowIdx];
+    // Clamp to reasonable range
+    return Math.max(0.3, Math.min(0.9, threshold));
+}
+export function clusterWithThresholdFromDistMatrix(n, precomputedDist, threshold) {
+    if (n === 0)
+        return [];
+    if (n === 1)
+        return [[0]];
+    const clusterMembers = [];
+    for (let i = 0; i < n; i++)
+        clusterMembers.push([i]);
+    const active = new Set();
+    for (let i = 0; i < n; i++)
+        active.add(i);
+    const distKey = (i, j) => i < j ? `${i}:${j}` : `${j}:${i}`;
+    const distMatrix = new Map(precomputedDist);
+    while (active.size > 1) {
+        let minDist = Infinity;
+        let mergeI = -1;
+        let mergeJ = -1;
+        for (const i of active) {
+            for (const j of active) {
+                if (i >= j)
+                    continue;
+                const d = distMatrix.get(distKey(i, j)) ?? Infinity;
+                if (d < minDist) {
+                    minDist = d;
+                    mergeI = i;
+                    mergeJ = j;
+                }
+            }
+        }
+        if (mergeI === -1 || minDist > threshold)
+            break;
+        // Average linkage merge
+        const sizeI = clusterMembers[mergeI].length;
+        const sizeJ = clusterMembers[mergeJ].length;
+        const newSize = sizeI + sizeJ;
+        clusterMembers[mergeI].push(...clusterMembers[mergeJ]);
+        active.delete(mergeJ);
+        for (const k of active) {
+            if (k === mergeI)
+                continue;
+            const distIK = distMatrix.get(distKey(mergeI, k)) ?? 1.0;
+            const distJK = distMatrix.get(distKey(mergeJ, k)) ?? 1.0;
+            const newDist = (distIK * sizeI + distJK * sizeJ) / newSize;
+            distMatrix.set(distKey(mergeI, k), newDist);
+        }
+    }
+    return [...active].map((i) => clusterMembers[i]);
+}
+/**
+ * Split oversized clusters by re-clustering their members with a stricter
+ * (halved) threshold. This prevents a single catch-all cluster from
+ * dominating the graph when the global elbow threshold is too loose.
+ *
+ * maxClusterRatio: a cluster with > (totalSessions * ratio) members is re-split.
+ * Default 0.25 = 25% of all sessions.
+ */
+export function splitOversizedClusters(clusters, totalSessions, precomputedDist, maxClusterRatio = 0.25) {
+    const maxSize = Math.max(10, Math.floor(totalSessions * maxClusterRatio));
+    const result = [];
+    for (const members of clusters) {
+        if (members.length <= maxSize) {
+            result.push(members);
+            continue;
+        }
+        // Extract sub-distance-matrix for this cluster's members
+        const n = members.length;
+        const subDist = new Map();
+        const distKey = (i, j) => i < j ? `${i}:${j}` : `${j}:${i}`;
+        const origDistKey = (i, j) => i < j ? `${i}:${j}` : `${j}:${i}`;
+        for (let i = 0; i < n; i++) {
+            for (let j = i + 1; j < n; j++) {
+                const origI = members[i];
+                const origJ = members[j];
+                const d = precomputedDist.get(origDistKey(origI, origJ)) ?? 1.0;
+                subDist.set(distKey(i, j), d);
+            }
+        }
+        // Find sub-elbow threshold from this cluster's internal distances
+        const internalDists = [];
+        for (const [, d] of subDist) {
+            internalDists.push(d);
+        }
+        internalDists.sort((a, b) => a - b);
+        // Use a stricter threshold: median of internal distances
+        const medianDist = internalDists[Math.floor(internalDists.length / 2)] ?? 0.5;
+        const subThreshold = Math.max(0.15, medianDist * 0.8);
+        const subClusters = clusterWithThresholdFromDistMatrix(n, subDist, subThreshold);
+        // Map sub-cluster indices back to original indices
+        for (const subMembers of subClusters) {
+            result.push(subMembers.map((i) => members[i]));
+        }
+    }
+    return result;
+}

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

@@ -0,0 +1,220 @@
+/**
+ * Louvain community detection and Brandes betweenness centrality.
+ */
+export function louvainDetection(topics, edges) {
+    const n = topics.length;
+    if (n === 0)
+        return { communities: [], modularity: 0 };
+    const nodeIndex = new Map();
+    topics.forEach((t, i) => nodeIndex.set(t.id, i));
+    // Build adjacency with weights
+    const adjWeights = Array.from({ length: n }, () => new Array(n).fill(0));
+    let totalWeight = 0;
+    for (const e of edges) {
+        const i = nodeIndex.get(e.source);
+        const j = nodeIndex.get(e.target);
+        if (i === undefined || j === undefined)
+            continue;
+        adjWeights[i][j] = e.strength;
+        adjWeights[j][i] = e.strength;
+        totalWeight += e.strength;
+    }
+    if (totalWeight === 0) {
+        // No edges: each node is its own community
+        const communities = topics.map((t, i) => ({
+            id: i,
+            topicIds: [t.id],
+            label: t.keywords[0] || t.label,
+            dominantProject: t.project,
+        }));
+        return { communities, modularity: 0 };
+    }
+    const m2 = totalWeight; // sum of all edge weights (each edge counted once)
+    // Node strengths (weighted degree)
+    const k = new Float64Array(n);
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+            k[i] += adjWeights[i][j];
+        }
+    }
+    // Community assignments
+    const community = new Int32Array(n);
+    for (let i = 0; i < n; i++)
+        community[i] = i;
+    // Phase 1: Local modularity optimization
+    let improved = true;
+    const maxIter = 100;
+    let iter = 0;
+    while (improved && iter < maxIter) {
+        improved = false;
+        iter++;
+        for (let i = 0; i < n; i++) {
+            const currentComm = community[i];
+            // Compute sum of weights to each neighboring community
+            const commWeights = new Map();
+            for (let j = 0; j < n; j++) {
+                if (adjWeights[i][j] > 0 && i !== j) {
+                    const c = community[j];
+                    commWeights.set(c, (commWeights.get(c) || 0) + adjWeights[i][j]);
+                }
+            }
+            // Sum of weights in current community
+            const ki = k[i];
+            // Try moving to each neighboring community
+            let bestComm = currentComm;
+            let bestDeltaQ = 0;
+            // Remove node i from its current community and compute cost
+            let sumCurrentComm = 0;
+            let kCurrentComm = 0;
+            for (let j = 0; j < n; j++) {
+                if (j !== i && community[j] === currentComm) {
+                    sumCurrentComm += adjWeights[i][j];
+                    kCurrentComm += k[j];
+                }
+            }
+            for (const [targetComm, wToComm] of commWeights) {
+                if (targetComm === currentComm)
+                    continue;
+                // Sum of weights of nodes in target community
+                let kTargetComm = 0;
+                for (let j = 0; j < n; j++) {
+                    if (community[j] === targetComm) {
+                        kTargetComm += k[j];
+                    }
+                }
+                // deltaQ = [w_to_target / m - ki * k_target / (2m²)] - [w_to_current / m - ki * k_current / (2m²)]
+                const deltaQ = (wToComm - sumCurrentComm) / m2 -
+                    (ki * (kTargetComm - kCurrentComm)) / (2 * m2 * m2);
+                if (deltaQ > bestDeltaQ) {
+                    bestDeltaQ = deltaQ;
+                    bestComm = targetComm;
+                }
+            }
+            if (bestComm !== currentComm) {
+                community[i] = bestComm;
+                improved = true;
+            }
+        }
+    }
+    // Compute modularity Q
+    let modularity = 0;
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+            if (community[i] === community[j]) {
+                modularity += adjWeights[i][j] - (k[i] * k[j]) / (2 * m2);
+            }
+        }
+    }
+    modularity /= 2 * m2;
+    // Build community objects
+    const commGroups = new Map();
+    for (let i = 0; i < n; i++) {
+        const c = community[i];
+        const group = commGroups.get(c) || [];
+        group.push(i);
+        commGroups.set(c, group);
+    }
+    // Renumber communities
+    let commIdx = 0;
+    const communities = [];
+    for (const [, members] of commGroups) {
+        const topicIds = members.map((i) => topics[i].id);
+        // Label from most frequent keywords
+        const kwCount = new Map();
+        for (const i of members) {
+            for (const kw of topics[i].keywords) {
+                kwCount.set(kw, (kwCount.get(kw) || 0) + 1);
+            }
+        }
+        const topKw = [...kwCount.entries()]
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 3)
+            .map(([kw]) => kw);
+        // Dominant project
+        const projCount = new Map();
+        for (const i of members) {
+            projCount.set(topics[i].project, (projCount.get(topics[i].project) || 0) + 1);
+        }
+        const dominantProject = [...projCount.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? "";
+        // Assign community ID to topics
+        for (const i of members) {
+            topics[i].communityId = commIdx;
+        }
+        communities.push({
+            id: commIdx,
+            topicIds,
+            label: topKw.join(", ") || `Community ${commIdx}`,
+            dominantProject,
+        });
+        commIdx++;
+    }
+    return { communities, modularity };
+}
+export function brandesBetweenness(topics, edges) {
+    const n = topics.length;
+    if (n <= 2)
+        return;
+    const nodeIndex = new Map();
+    topics.forEach((t, i) => nodeIndex.set(t.id, i));
+    // Build adjacency list
+    const adj = Array.from({ length: n }, () => []);
+    for (const e of edges) {
+        const i = nodeIndex.get(e.source);
+        const j = nodeIndex.get(e.target);
+        if (i === undefined || j === undefined)
+            continue;
+        adj[i].push(j);
+        adj[j].push(i);
+    }
+    const CB = new Float64Array(n);
+    for (let s = 0; s < n; s++) {
+        // BFS from s
+        const stack = [];
+        const pred = Array.from({ length: n }, () => []);
+        const sigma = new Float64Array(n);
+        sigma[s] = 1;
+        const dist = new Int32Array(n).fill(-1);
+        dist[s] = 0;
+        const queue = [s];
+        while (queue.length > 0) {
+            const v = queue.shift();
+            stack.push(v);
+            for (const w of adj[v]) {
+                if (dist[w] < 0) {
+                    dist[w] = dist[v] + 1;
+                    queue.push(w);
+                }
+                if (dist[w] === dist[v] + 1) {
+                    sigma[w] += sigma[v];
+                    pred[w].push(v);
+                }
+            }
+        }
+        // Back-propagation
+        const delta = new Float64Array(n);
+        while (stack.length > 0) {
+            const w = stack.pop();
+            for (const v of pred[w]) {
+                delta[v] += (sigma[v] / sigma[w]) * (1 + delta[w]);
+            }
+            if (w !== s) {
+                CB[w] += delta[w];
+            }
+        }
+    }
+    // Normalize for undirected graph: divide by 2
+    const normFactor = n > 2 ? 2 / ((n - 1) * (n - 2)) : 1;
+    for (let i = 0; i < n; i++) {
+        CB[i] = (CB[i] / 2) * normFactor;
+    }
+    // Assign to topic nodes
+    for (let i = 0; i < n; i++) {
+        topics[i].betweennessCentrality = Math.round(CB[i] * 10000) / 10000;
+    }
+    // Degree centrality
+    for (let i = 0; i < n; i++) {
+        const degree = adj[i].length;
+        topics[i].degreeCentrality =
+            n > 1 ? Math.round((degree / (n - 1)) * 10000) / 10000 : 0;
+    }
+}

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

@@ -0,0 +1,58 @@
+/**
+ * Constants for knowledge graph construction.
+ */
+// ─── Stop words ─────────────────────────────────────────────────────────────
+export const STOP_WORDS = new Set([
+    // English
+    "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
+    "have", "has", "had", "do", "does", "did", "will", "would", "could",
+    "should", "may", "might", "shall", "can", "need", "must", "ought",
+    "i", "you", "he", "she", "it", "we", "they", "me", "him", "her",
+    "us", "them", "my", "your", "his", "its", "our", "their", "mine",
+    "yours", "hers", "ours", "theirs", "this", "that", "these", "those",
+    "what", "which", "who", "whom", "whose", "when", "where", "why", "how",
+    "all", "each", "every", "both", "few", "more", "most", "other", "some",
+    "such", "no", "nor", "not", "only", "own", "same", "so", "than", "too",
+    "very", "just", "because", "as", "until", "while", "of", "at", "by",
+    "for", "with", "about", "against", "between", "through", "during",
+    "before", "after", "above", "below", "to", "from", "up", "down", "in",
+    "out", "on", "off", "over", "under", "again", "further", "then", "once",
+    "here", "there", "and", "but", "or", "if", "else", "also", "like",
+    "please", "thanks", "thank", "yes", "no", "ok", "okay", "sure", "let",
+    "make", "use", "using", "used", "want", "see", "look", "try", "get",
+    "got", "think", "know", "now", "new", "way", "well", "back", "still",
+    "file", "code", "change", "changes", "add", "update", "fix", "set",
+    // Japanese particles and common words
+    "の", "に", "は", "を", "が", "で", "と", "も", "か", "な", "だ",
+    "です", "ます", "する", "した", "して", "ない", "ある", "いる",
+    "これ", "それ", "あれ", "この", "その", "あの", "ここ", "そこ",
+    "こと", "もの", "ため", "よう", "から", "まで", "より", "ほど",
+    "など", "ので", "けど", "でも", "しかし", "また", "そして",
+    "って", "という", "ください", "お願い", "確認",
+]);
+// ─── Noise token patterns ───────────────────────────────────────────────────
+export const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+export const HEX_PATTERN = /^[0-9a-f]{6,}$/i;
+export const NUM_PATTERN = /^\d+$/;
+// ─── Structural features ────────────────────────────────────────────────────
+export const STRUCTURAL_DIM = 7;
+// ─── Feature weights ────────────────────────────────────────────────────────
+export const WEIGHT_TEXT = 0.50;
+export const WEIGHT_TOOL = 0.25;
+export const WEIGHT_STRUCT = 0.25;
+// ─── Action verbs ───────────────────────────────────────────────────────────
+export const ACTION_VERBS_EN = new Set([
+    "fix", "add", "implement", "create", "update", "refactor", "remove",
+    "delete", "move", "rename", "test", "debug", "optimize", "migrate",
+    "deploy", "configure", "setup", "integrate", "build", "review",
+    "investigate", "analyze", "check", "resolve", "extract", "convert",
+]);
+export const ACTION_VERBS_JA = [
+    [/修正/, "fix"], [/追加/, "add"], [/実装/, "implement"],
+    [/作成|作って/, "create"], [/更新/, "update"], [/リファクタ/, "refactor"],
+    [/削除/, "remove"], [/テスト/, "test"], [/デバッグ/, "debug"],
+    [/最適化/, "optimize"], [/移行|マイグレ/, "migrate"],
+    [/設定|セットアップ/, "configure"], [/統合/, "integrate"],
+    [/ビルド/, "build"], [/レビュー/, "review"], [/調査/, "investigate"],
+    [/確認|チェック/, "check"], [/解決/, "resolve"],
+];