claude-slim 2.6.1 → 2.7.1

package/dist/scanner/sessions.js

@@ -79,6 +79,117 @@ export function extractSkillsFromTranscript(content) {
     }
     return skills;
 }
+// Extract MCP server prefixes from tool_use events whose name matches
+// `mcp__<prefix>__<tool>`. Returns the set of unique prefixes seen.
+//
+// Example: `mcp__plugin_oh-my-claudecode_t__lsp_diagnostics` → `plugin_oh-my-claudecode_t`
+export function extractMcpPrefixesFromTranscript(content) {
+    const prefixes = new Set();
+    const lines = content.split('\n');
+    for (const line of lines) {
+        if (!line)
+            continue;
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (typeof obj !== 'object' || obj === null)
+            continue;
+        const message = obj.message;
+        if (typeof message !== 'object' || message === null)
+            continue;
+        const msgContent = message.content;
+        if (!Array.isArray(msgContent))
+            continue;
+        for (const c of msgContent) {
+            if (typeof c !== 'object' || c === null)
+                continue;
+            const rec = c;
+            if (rec.type !== 'tool_use')
+                continue;
+            const name = rec.name;
+            if (typeof name !== 'string' || !name.startsWith('mcp__'))
+                continue;
+            // Must have at least two __ separators: mcp__<prefix>__<tool>
+            const after = name.slice('mcp__'.length);
+            const sep = after.indexOf('__');
+            if (sep === -1)
+                continue;
+            prefixes.add(after.slice(0, sep));
+        }
+    }
+    return prefixes;
+}
+// Extract slash command names from user messages containing the
+// `<command-name>/foo</command-name>` tag that Claude Code injects when a
+// user runs a slash command. The leading slash is stripped so callers receive
+// plain names like "clear" or "grill-me".
+//
+// Only `type === "user"` / `role === "user"` messages are examined to avoid
+// false positives from assistant text that may reference command names.
+// Regex pattern held as a plain string — each call site constructs a fresh
+// RegExp so there is no shared `lastIndex` state to reset. `String.matchAll`
+// then wraps that RegExp in its own iterator, further insulating the loop.
+const COMMAND_TAG_PATTERN = /<command-name>([^<]+)<\/command-name>/g;
+export function extractCommandsFromTranscript(content) {
+    const commands = new Set();
+    const lines = content.split('\n');
+    for (const line of lines) {
+        if (!line)
+            continue;
+        let obj;
+        try {
+            obj = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (typeof obj !== 'object' || obj === null)
+            continue;
+        const rec = obj;
+        // Only inspect user-role messages
+        const message = rec.message;
+        if (typeof message !== 'object' || message === null)
+            continue;
+        const msgRec = message;
+        if (msgRec.role !== 'user')
+            continue;
+        const msgContent = msgRec.content;
+        // User content may be a plain string or an array of content blocks.
+        const texts = [];
+        if (typeof msgContent === 'string') {
+            texts.push(msgContent);
+        }
+        else if (Array.isArray(msgContent)) {
+            for (const c of msgContent) {
+                if (typeof c !== 'object' || c === null)
+                    continue;
+                const text = c.text;
+                if (typeof text === 'string')
+                    texts.push(text);
+            }
+        }
+        for (const text of texts) {
+            for (const match of text.matchAll(COMMAND_TAG_PATTERN)) {
+                // Strip leading slash from the command value (e.g. "/clear" → "clear")
+                const raw = match[1].trim();
+                commands.add(raw.startsWith('/') ? raw.slice(1) : raw);
+            }
+        }
+    }
+    return commands;
+}
+// Parse all signals from a single JSONL transcript.
+function parseTranscript(content) {
+    const skills = extractSkillsFromTranscript(content);
+    const mcpPrefixes = Array.from(extractMcpPrefixesFromTranscript(content));
+    const commands = Array.from(extractCommandsFromTranscript(content));
+    const invocationCount = skills.length + mcpPrefixes.length + commands.length;
+    return { skills, mcpPrefixes, commands, invocationCount };
+}
 // Walk every `~/.claude/projects/<slug>/*.jsonl` whose mtime falls inside the
 // lookback window. Per-file results are cached by mtime, so warm scans only
 // re-read files that have changed.
@@ -90,6 +201,9 @@ export async function scanSessionUsage(lookbackDays) {
     // across many scans even as old session logs get rotated/deleted.
     const newEntries = {};
     const invokedSkills = new Set();
+    const mcpPrefixesInvoked = new Set();
+    const commandsInvoked = new Set();
+    let totalUserCallableInvocations = 0;
     let sessionsScanned = 0;
     let sessionsInWindow = 0;
     let projectDirs = [];
@@ -97,7 +211,15 @@ export async function scanSessionUsage(lookbackDays) {
         projectDirs = await readdir(projectsDir);
     }
     catch {
-        return { invokedSkills, dataAvailable: false, sessionsScanned: 0, sessionsInWindow: 0 };
+        return {
+            invokedSkills,
+            dataAvailable: false,
+            sessionsScanned: 0,
+            sessionsInWindow: 0,
+            mcpPrefixesInvoked,
+            commandsInvoked,
+            totalUserCallableInvocations: 0,
+        };
     }
     for (const projectName of projectDirs) {
         const projectPath = join(projectsDir, projectName);
@@ -123,11 +245,21 @@ export async function scanSessionUsage(lookbackDays) {
             if (mtimeMs < cutoffMs)
                 continue;
             sessionsInWindow++;
-            // Cache hit: reuse the parsed skill list, no I/O on the file body.
+            // Cache hit: reuse the parsed result only if mtime matches AND the entry
+            // has the v2.6 extension fields (mcpPrefixes / commands). Entries from
+            // older cache files lack these fields → force a re-parse.
             const cached = cache.entries[filePath];
-            if (cached && cached.mtimeMs === mtimeMs) {
+            if (cached &&
+                cached.mtimeMs === mtimeMs &&
+                Array.isArray(cached.mcpPrefixes) &&
+                Array.isArray(cached.commands)) {
                 for (const s of cached.skills)
                     invokedSkills.add(s);
+                for (const p of cached.mcpPrefixes)
+                    mcpPrefixesInvoked.add(p);
+                for (const cmd of cached.commands)
+                    commandsInvoked.add(cmd);
+                totalUserCallableInvocations += cached.invocationCount ?? 0;
                 newEntries[filePath] = cached;
                 continue;
             }
@@ -138,13 +270,32 @@ export async function scanSessionUsage(lookbackDays) {
             catch {
                 continue;
             }
-            const skills = extractSkillsFromTranscript(content);
-            for (const s of skills)
+            const parsed = parseTranscript(content);
+            for (const s of parsed.skills)
                 invokedSkills.add(s);
-            newEntries[filePath] = { mtimeMs, skills: Array.from(new Set(skills)) };
+            for (const p of parsed.mcpPrefixes)
+                mcpPrefixesInvoked.add(p);
+            for (const cmd of parsed.commands)
+                commandsInvoked.add(cmd);
+            totalUserCallableInvocations += parsed.invocationCount;
+            newEntries[filePath] = {
+                mtimeMs,
+                skills: Array.from(new Set(parsed.skills)),
+                mcpPrefixes: Array.from(new Set(parsed.mcpPrefixes)),
+                commands: Array.from(new Set(parsed.commands)),
+                invocationCount: parsed.invocationCount,
+            };
         }
     }
     const dataAvailable = sessionsInWindow >= MIN_SESSIONS_FOR_DATA_AVAILABLE && invokedSkills.size > 0;
     await saveCache({ version: CACHE_VERSION, entries: newEntries });
-    return { invokedSkills, dataAvailable, sessionsScanned, sessionsInWindow };
+    return {
+        invokedSkills,
+        dataAvailable,
+        sessionsScanned,
+        sessionsInWindow,
+        mcpPrefixesInvoked,
+        commandsInvoked,
+        totalUserCallableInvocations,
+    };
 }

package/dist/types.d.ts

@@ -25,7 +25,7 @@ export interface PluginInfo {
     status?: 'enabled' | 'disabled';
 }
 export type IssueTier = 1 | 2 | 3;
-export type IssueType = 'broken_symlink' | 'template' | 'skill_dup' | 'duplicate' | 'oversized_memory' | 'oversized_skill' | 'unused_skill' | 'disabled_plugin' | 'stale_project' | 'temp_cache';
+export type IssueType = 'broken_symlink' | 'template' | 'skill_dup' | 'duplicate' | 'oversized_memory' | 'oversized_skill' | 'unused_skill' | 'unused_plugin' | 'disabled_plugin' | 'stale_project' | 'temp_cache';
 export interface Issue {
     type: IssueType;
     tier: IssueTier;
@@ -33,6 +33,17 @@ export interface Issue {
     detail?: string;
     tokens: number;
     path: string;
+    marketplace?: string;
+}
+export interface PluginBreakdown {
+    name: string;
+    marketplace: string;
+    tokens: number;
+    skills: number;
+    mcp: number;
+    commands: number;
+    lastUsed: 'used' | 'never';
+    status: 'used' | 'unused' | 'agent-only' | 'insufficient data' | 'disabled';
 }
 export interface ScanResult {
     localSkills: SkillInfo[];
@@ -51,6 +62,7 @@ export interface ScanResult {
     mcpServerNames: string[];
     issues: Issue[];
     totalTokensBefore: number;
+    pluginBreakdown: PluginBreakdown[];
 }
 export interface ManifestEntry {
     date: string;
@@ -60,9 +72,17 @@ export interface ManifestEntry {
     tokenCount?: number;
     tier?: IssueTier;
 }
+export type LegacyManifestEntry = ManifestEntry;
+export interface DisabledPluginEntry {
+    type: 'disabled_plugin';
+    plugin: string;
+    marketplace: string;
+    disabledAt: string;
+}
+export type AnyManifestEntry = ManifestEntry | DisabledPluginEntry;
 export interface Manifest {
     version: 2;
-    entries: ManifestEntry[];
+    entries: AnyManifestEntry[];
 }
 export interface TokenCache {
     version: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-slim",
-  "version": "2.6.1",
+  "version": "2.7.1",
   "description": "Analyze and reduce Claude Code token overhead",
   "type": "module",
   "bin": {