claude-slim 2.2.3 → 2.4.0

package/dist/scanner/index.js

@@ -0,0 +1,62 @@
+import { join } from 'node:path';
+import { countTokensCached } from '../tokenizer.js';
+import { getClaudeDir } from '../paths.js';
+import { safeReadFile } from './fs-walk.js';
+import { scanLocalSkills } from './local-skills.js';
+import { scanPluginSkills } from './plugin-skills.js';
+import { scanMemoryFiles } from './memory.js';
+import { scanMcpServers } from './mcp.js';
+import { parseClaudeMdSections } from './claude-md.js';
+import { getDisabledPlugins } from './disabled-plugins.js';
+import { scanSessionUsage } from './sessions.js';
+import { classifyIssues } from './detectors.js';
+import { SKILL_PROMPT_OVERHEAD_TOKENS } from './constants.js';
+const DEFAULT_LOOKBACK_DAYS = 60;
+export async function scan(opts = {}) {
+    const lookbackDays = opts.lookbackDays ?? DEFAULT_LOOKBACK_DAYS;
+    const [{ skills: localSkills, brokenSymlinks, contents }, { skills: pluginSkills, plugins, tempCaches }, { memoryFiles, staleProjects }, mcp, disabledPlugins, sessionUsage,] = await Promise.all([
+        scanLocalSkills(),
+        scanPluginSkills(),
+        scanMemoryFiles(),
+        scanMcpServers(),
+        getDisabledPlugins(),
+        scanSessionUsage(lookbackDays),
+    ]);
+    // Annotate plugin status
+    for (const plugin of plugins) {
+        plugin.status = disabledPlugins.has(plugin.name) ? 'disabled' : 'enabled';
+    }
+    // CLAUDE.md
+    const claudeMdContent = await safeReadFile(join(getClaudeDir(), 'CLAUDE.md'));
+    const claudeMdBytes = claudeMdContent ? Buffer.byteLength(claudeMdContent) : 0;
+    const claudeMdTokens = claudeMdContent
+        ? countTokensCached(claudeMdContent, join(getClaudeDir(), 'CLAUDE.md'))
+        : 0;
+    const claudeMdSections = claudeMdContent ? parseClaudeMdSections(claudeMdContent) : [];
+    const issues = classifyIssues({
+        localSkills, pluginSkills, brokenSymlinks, memoryFiles,
+        tempCaches, staleProjects, disabledPlugins, plugins,
+        contents,
+        recentSkillInvocations: sessionUsage.invokedSkills,
+        sessionDataAvailable: sessionUsage.dataAvailable,
+        lookbackDays,
+    });
+    // Estimate total tokens at startup
+    const skillListingTokens = (localSkills.length + pluginSkills.length) * SKILL_PROMPT_OVERHEAD_TOKENS;
+    const memoryTokens = memoryFiles.reduce((sum, m) => sum + m.tokens, 0);
+    const totalTokensBefore = skillListingTokens + claudeMdTokens + memoryTokens;
+    return {
+        localSkills,
+        pluginSkills,
+        plugins,
+        brokenSymlinks,
+        memoryFiles,
+        claudeMdBytes,
+        claudeMdTokens,
+        claudeMdSections,
+        mcpServers: mcp.count,
+        mcpServerNames: mcp.names,
+        issues,
+        totalTokensBefore,
+    };
+}

package/dist/scanner/local-skills.d.ts

@@ -0,0 +1,12 @@
+import type { SkillInfo, BrokenSymlink } from '../types.js';
+export interface SkillCandidate {
+    skill: SkillInfo;
+    realMdPath: string;
+}
+export declare function dedupeBySymlink(candidates: SkillCandidate[]): SkillInfo[];
+export interface LocalSkillsResult {
+    skills: SkillInfo[];
+    brokenSymlinks: BrokenSymlink[];
+    contents: Map<string, string>;
+}
+export declare function scanLocalSkills(): Promise<LocalSkillsResult>;

package/dist/scanner/local-skills.js

@@ -0,0 +1,97 @@
+import { readlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { countTokensCached } from '../tokenizer.js';
+import { getSkillsDir } from '../paths.js';
+import { safeReadFile, safeReaddir, isDirectory, isBrokenSymlink, resolveRealPath, } from './fs-walk.js';
+export function dedupeBySymlink(candidates) {
+    const seen = new Map();
+    for (const { skill, realMdPath } of candidates) {
+        const existing = seen.get(realMdPath);
+        if (!existing) {
+            seen.set(realMdPath, skill);
+            continue;
+        }
+        // Prefer top-level name (no slash) over nested duplicate
+        const existingIsNested = existing.name.includes('/');
+        const currentIsNested = skill.name.includes('/');
+        if (existingIsNested && !currentIsNested) {
+            seen.set(realMdPath, skill);
+        }
+    }
+    return Array.from(seen.values());
+}
+export async function scanLocalSkills() {
+    const skillsDir = getSkillsDir();
+    const candidates = [];
+    const brokenSymlinks = [];
+    const contents = new Map();
+    const entries = await safeReaddir(skillsDir);
+    const scanPromises = entries.map(async (entry) => {
+        const dirPath = join(skillsDir, entry);
+        if (!(await isDirectory(dirPath)))
+            return;
+        const skillMd = join(dirPath, 'SKILL.md');
+        if (await isBrokenSymlink(skillMd)) {
+            let target = 'unknown';
+            try {
+                target = await readlink(skillMd);
+            }
+            catch { /* */ }
+            brokenSymlinks.push({ name: entry, path: skillMd, target });
+            return;
+        }
+        const content = await safeReadFile(skillMd);
+        if (content !== null) {
+            contents.set(skillMd, content);
+            const tokens = countTokensCached(content, skillMd);
+            const realMdPath = await resolveRealPath(skillMd);
+            candidates.push({
+                skill: {
+                    name: entry,
+                    path: dirPath,
+                    sizeBytes: Buffer.byteLength(content),
+                    tokens,
+                    source: 'local',
+                },
+                realMdPath,
+            });
+        }
+        // Nested skills (e.g., @internal-sys/commit-guide)
+        const subEntries = await safeReaddir(dirPath);
+        for (const sub of subEntries) {
+            const subDir = join(dirPath, sub);
+            if (!(await isDirectory(subDir)))
+                continue;
+            const subSkillMd = join(subDir, 'SKILL.md');
+            if (await isBrokenSymlink(subSkillMd)) {
+                let target = 'unknown';
+                try {
+                    target = await readlink(subSkillMd);
+                }
+                catch { /* */ }
+                brokenSymlinks.push({ name: `${entry}/${sub}`, path: subSkillMd, target });
+                continue;
+            }
+            const subContent = await safeReadFile(subSkillMd);
+            if (subContent !== null) {
+                const name = `${entry}/${sub}`;
+                contents.set(subSkillMd, subContent);
+                const tokens = countTokensCached(subContent, subSkillMd);
+                const realMdPath = await resolveRealPath(subSkillMd);
+                candidates.push({
+                    skill: {
+                        name,
+                        path: subDir,
+                        sizeBytes: Buffer.byteLength(subContent),
+                        tokens,
+                        source: 'local',
+                    },
+                    realMdPath,
+                });
+            }
+        }
+    });
+    await Promise.all(scanPromises);
+    const skills = dedupeBySymlink(candidates);
+    return { skills, brokenSymlinks, contents };
+}

package/dist/scanner/mcp.d.ts

@@ -0,0 +1,5 @@
+export interface McpScanResult {
+    count: number;
+    names: string[];
+}
+export declare function scanMcpServers(): Promise<McpScanResult>;

package/dist/scanner/mcp.js

@@ -0,0 +1,17 @@
+import { join } from 'node:path';
+import { getClaudeDir } from '../paths.js';
+import { safeReadFile } from './fs-walk.js';
+export async function scanMcpServers() {
+    const content = await safeReadFile(join(getClaudeDir(), 'settings.json'));
+    if (!content)
+        return { count: 0, names: [] };
+    try {
+        const data = JSON.parse(content);
+        const servers = data.mcpServers || {};
+        const names = Object.keys(servers).sort();
+        return { count: names.length, names };
+    }
+    catch {
+        return { count: 0, names: [] };
+    }
+}

package/dist/scanner/memory.d.ts

@@ -0,0 +1,13 @@
+import type { MemoryFile } from '../types.js';
+export interface StaleProject {
+    project: string;
+    path: string;
+    ageDays: number;
+    fileCount: number;
+    totalBytes: number;
+}
+export interface MemoryScanResult {
+    memoryFiles: MemoryFile[];
+    staleProjects: StaleProject[];
+}
+export declare function scanMemoryFiles(): Promise<MemoryScanResult>;

package/dist/scanner/memory.js

@@ -0,0 +1,50 @@
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { countTokensCached } from '../tokenizer.js';
+import { getProjectsDir } from '../paths.js';
+import { safeReadFile, safeReaddir } from './fs-walk.js';
+import { STALE_DAYS } from './constants.js';
+export async function scanMemoryFiles() {
+    const memoryFiles = [];
+    const staleProjects = [];
+    const projectsDir = getProjectsDir();
+    const projectDirs = await safeReaddir(projectsDir);
+    const now = Date.now();
+    const scanPromises = projectDirs.map(async (project) => {
+        const memDir = join(projectsDir, project, 'memory');
+        const files = await safeReaddir(memDir);
+        const mdFiles = files.filter((f) => f.endsWith('.md'));
+        let newestMtime = 0;
+        let totalBytes = 0;
+        for (const file of mdFiles) {
+            const filePath = join(memDir, file);
+            const content = await safeReadFile(filePath);
+            if (content !== null) {
+                const sizeBytes = Buffer.byteLength(content);
+                memoryFiles.push({
+                    project,
+                    name: file,
+                    path: filePath,
+                    sizeBytes,
+                    tokens: countTokensCached(content, filePath),
+                });
+                totalBytes += sizeBytes;
+                try {
+                    const s = await stat(filePath);
+                    if (s.mtimeMs > newestMtime)
+                        newestMtime = s.mtimeMs;
+                }
+                catch { /* skip */ }
+            }
+        }
+        // Check for stale project (no files modified in 90+ days)
+        if (mdFiles.length > 0 && newestMtime > 0) {
+            const ageDays = Math.floor((now - newestMtime) / (1000 * 60 * 60 * 24));
+            if (ageDays > STALE_DAYS) {
+                staleProjects.push({ project, path: memDir, ageDays, fileCount: mdFiles.length, totalBytes });
+            }
+        }
+    });
+    await Promise.all(scanPromises);
+    return { memoryFiles, staleProjects };
+}

package/dist/scanner/plugin-skills.d.ts

@@ -0,0 +1,12 @@
+import type { SkillInfo, PluginInfo } from '../types.js';
+export interface TempCache {
+    name: string;
+    path: string;
+    sizeKB: number;
+}
+export interface PluginSkillsResult {
+    skills: SkillInfo[];
+    plugins: PluginInfo[];
+    tempCaches: TempCache[];
+}
+export declare function scanPluginSkills(): Promise<PluginSkillsResult>;

package/dist/scanner/plugin-skills.js

@@ -0,0 +1,65 @@
+import { join } from 'node:path';
+import { countTokensCached } from '../tokenizer.js';
+import { getPluginsDir } from '../paths.js';
+import { safeReadFile, safeReaddir, isDirectory, getDirSize } from './fs-walk.js';
+export async function scanPluginSkills() {
+    const skills = [];
+    const plugins = [];
+    const tempCaches = [];
+    const pluginsDir = getPluginsDir();
+    const pluginDirs = await safeReaddir(pluginsDir);
+    const scanPromises = pluginDirs.map(async (pluginName) => {
+        const pluginDir = join(pluginsDir, pluginName);
+        if (!(await isDirectory(pluginDir)))
+            return;
+        // Detect temp_local_* cache dirs (failed plugin installs)
+        if (pluginName.startsWith('temp_local_')) {
+            const size = await getDirSize(pluginDir);
+            tempCaches.push({ name: pluginName, path: pluginDir, sizeKB: Math.round(size / 1024) });
+            return;
+        }
+        const pluginSkillNames = [];
+        const walkDir = async (dir) => {
+            const entries = await safeReaddir(dir);
+            for (const entry of entries) {
+                const entryPath = join(dir, entry);
+                if (!(await isDirectory(entryPath)))
+                    continue;
+                if (entry === 'skills') {
+                    const skillDirs = await safeReaddir(entryPath);
+                    for (const skillDir of skillDirs) {
+                        const skillPath = join(entryPath, skillDir);
+                        if (!(await isDirectory(skillPath)))
+                            continue;
+                        const skillMd = join(skillPath, 'SKILL.md');
+                        const content = await safeReadFile(skillMd);
+                        if (content !== null) {
+                            pluginSkillNames.push(skillDir);
+                            skills.push({
+                                name: skillDir,
+                                path: skillPath,
+                                sizeBytes: Buffer.byteLength(content),
+                                tokens: countTokensCached(content, skillMd),
+                                source: 'plugin',
+                                pluginName,
+                            });
+                        }
+                    }
+                }
+                else {
+                    await walkDir(entryPath);
+                }
+            }
+        };
+        await walkDir(pluginDir);
+        if (pluginSkillNames.length > 0) {
+            plugins.push({
+                name: pluginName,
+                skillCount: pluginSkillNames.length,
+                skills: pluginSkillNames,
+            });
+        }
+    });
+    await Promise.all(scanPromises);
+    return { skills, plugins, tempCaches };
+}

package/dist/scanner/sessions.d.ts

@@ -0,0 +1,8 @@
+export interface SessionScanResult {
+    invokedSkills: Set<string>;
+    dataAvailable: boolean;
+    sessionsScanned: number;
+    sessionsInWindow: number;
+}
+export declare function extractSkillsFromTranscript(content: string): string[];
+export declare function scanSessionUsage(lookbackDays: number): Promise<SessionScanResult>;

package/dist/scanner/sessions.js

@@ -0,0 +1,150 @@
+import { readFile, readdir, stat, writeFile, mkdir, rename } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+import { getClaudeDir } from '../paths.js';
+const CACHE_VERSION = 1;
+// Below this many sessions in the lookback window we suppress unused-skill
+// classification — too little signal, "unused" would be misleading.
+const MIN_SESSIONS_FOR_DATA_AVAILABLE = 3;
+function getCachePath() {
+    return join(getClaudeDir(), '.skill-usage-cache.json');
+}
+async function loadCache() {
+    try {
+        const raw = await readFile(getCachePath(), 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== CACHE_VERSION)
+            return { version: CACHE_VERSION, entries: {} };
+        return parsed;
+    }
+    catch {
+        return { version: CACHE_VERSION, entries: {} };
+    }
+}
+async function saveCache(cache) {
+    const target = getCachePath();
+    const tmp = target + '.tmp';
+    try {
+        await mkdir(dirname(target), { recursive: true });
+        // Atomic write — same pattern as token cache. A crash mid-flush leaves the
+        // prior cache intact rather than a torn JSON file.
+        await writeFile(tmp, JSON.stringify(cache));
+        await rename(tmp, target);
+    }
+    catch {
+        // Non-critical: missing cache just means a slower next scan.
+    }
+}
+// Extract Skill-tool invocations from a single JSONL session log.
+// Each line in `~/.claude/projects/<slug>/<sessionId>.jsonl` is a JSON event;
+// we look for `message.content[]` entries shaped
+//   { type: 'tool_use', name: 'Skill', input: { skill: '<id>' } }
+// and collect the `skill` strings (e.g. 'superpowers:brainstorming').
+//
+// Schema-defensive: any line/field that does not match is silently skipped,
+// so a partial schema change degrades gracefully rather than throwing.
+export function extractSkillsFromTranscript(content) {
+    const skills = [];
+    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' || rec.name !== 'Skill')
+                continue;
+            const input = rec.input;
+            if (typeof input !== 'object' || input === null)
+                continue;
+            const skill = input.skill;
+            if (typeof skill === 'string')
+                skills.push(skill);
+        }
+    }
+    return skills;
+}
+// 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.
+export async function scanSessionUsage(lookbackDays) {
+    const projectsDir = join(getClaudeDir(), 'projects');
+    const cutoffMs = Date.now() - lookbackDays * 24 * 60 * 60 * 1000;
+    const cache = await loadCache();
+    // Pruned cache: only entries seen this scan survive. Keeps the file bounded
+    // across many scans even as old session logs get rotated/deleted.
+    const newEntries = {};
+    const invokedSkills = new Set();
+    let sessionsScanned = 0;
+    let sessionsInWindow = 0;
+    let projectDirs = [];
+    try {
+        projectDirs = await readdir(projectsDir);
+    }
+    catch {
+        return { invokedSkills, dataAvailable: false, sessionsScanned: 0, sessionsInWindow: 0 };
+    }
+    for (const projectName of projectDirs) {
+        const projectPath = join(projectsDir, projectName);
+        let entries = [];
+        try {
+            entries = await readdir(projectPath);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.endsWith('.jsonl'))
+                continue;
+            const filePath = join(projectPath, entry);
+            let mtimeMs;
+            try {
+                mtimeMs = (await stat(filePath)).mtimeMs;
+            }
+            catch {
+                continue;
+            }
+            sessionsScanned++;
+            if (mtimeMs < cutoffMs)
+                continue;
+            sessionsInWindow++;
+            // Cache hit: reuse the parsed skill list, no I/O on the file body.
+            const cached = cache.entries[filePath];
+            if (cached && cached.mtimeMs === mtimeMs) {
+                for (const s of cached.skills)
+                    invokedSkills.add(s);
+                newEntries[filePath] = cached;
+                continue;
+            }
+            let content;
+            try {
+                content = await readFile(filePath, 'utf-8');
+            }
+            catch {
+                continue;
+            }
+            const skills = extractSkillsFromTranscript(content);
+            for (const s of skills)
+                invokedSkills.add(s);
+            newEntries[filePath] = { mtimeMs, skills: Array.from(new Set(skills)) };
+        }
+    }
+    const dataAvailable = sessionsInWindow >= MIN_SESSIONS_FOR_DATA_AVAILABLE && invokedSkills.size > 0;
+    await saveCache({ version: CACHE_VERSION, entries: newEntries });
+    return { invokedSkills, dataAvailable, sessionsScanned, sessionsInWindow };
+}

package/dist/scanner.d.ts

@@ -1,15 +1,5 @@
-import type { ScanResult, SkillInfo } from './types.js';
-export declare const SKILL_PROMPT_OVERHEAD_TOKENS = 30;
-interface SkillCandidate {
-    skill: SkillInfo;
-    realMdPath: string;
-}
-export declare function dedupeBySymlink(candidates: SkillCandidate[]): SkillInfo[];
-export declare function parseDisabledPlugins(output: string): Set<string>;
-export declare function parseClaudeMdSections(content: string): Array<{
-    name: string;
-    sizeBytes: number;
-    tokens: number;
-}>;
-export declare function scan(): Promise<ScanResult>;
-export {};
+export { scan } from './scanner/index.js';
+export { SKILL_PROMPT_OVERHEAD_TOKENS } from './scanner/constants.js';
+export { dedupeBySymlink } from './scanner/local-skills.js';
+export { parseDisabledPlugins } from './scanner/disabled-plugins.js';
+export { parseClaudeMdSections } from './scanner/claude-md.js';