claude-slim 2.2.2 → 2.3.0

package/dist/scanner.js

@@ -1,528 +1,8 @@
-import { readdir, readFile, readlink, stat, lstat, realpath } from 'node:fs/promises';
-import { join } from 'node:path';
-import { countTokensCached } from './tokenizer.js';
-import { getClaudeDir, getSkillsDir, getPluginsDir, getProjectsDir } from './paths.js';
-const STALE_DAYS = 90;
-const OVERSIZED_SKILL_BYTES = 10240;
-const OVERSIZED_MEMORY_BYTES = 5120;
-export const SKILL_PROMPT_OVERHEAD_TOKENS = 30;
-async function safeReadFile(p) {
-    try {
-        return await readFile(p, 'utf-8');
-    }
-    catch {
-        return null;
-    }
-}
-async function safeReaddir(p) {
-    try {
-        return await readdir(p);
-    }
-    catch {
-        return [];
-    }
-}
-async function isDirectory(p) {
-    try {
-        return (await stat(p)).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-async function isBrokenSymlink(p) {
-    try {
-        const lstats = await lstat(p);
-        if (!lstats.isSymbolicLink())
-            return false;
-        await realpath(p);
-        return false;
-    }
-    catch {
-        try {
-            return (await lstat(p)).isSymbolicLink();
-        }
-        catch {
-            return false;
-        }
-    }
-}
-async function runCommand(cmd) {
-    try {
-        const { exec } = await import('node:child_process');
-        return new Promise((resolve) => {
-            exec(cmd, { timeout: 10000 }, (_err, stdout) => {
-                resolve(stdout || '');
-            });
-        });
-    }
-    catch {
-        return '';
-    }
-}
-async function getDirSize(dir) {
-    let total = 0;
-    const entries = await safeReaddir(dir);
-    for (const entry of entries) {
-        const p = join(dir, entry);
-        try {
-            const s = await stat(p);
-            if (s.isFile())
-                total += s.size;
-            else if (s.isDirectory())
-                total += await getDirSize(p);
-        }
-        catch { /* skip */ }
-    }
-    return total;
-}
-// Content cache: avoids re-reading files during classification.
-// Reset on every scan() so repeat invocations (e.g. pre/post-cleanup) do
-// not accumulate entries for paths that no longer exist.
-const contentCache = new Map();
-async function resolveRealPath(p) {
-    try {
-        return await realpath(p);
-    }
-    catch {
-        return p;
-    }
-}
-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());
-}
-async function scanLocalSkills() {
-    const skillsDir = getSkillsDir();
-    const candidates = [];
-    const brokenSymlinks = [];
-    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) {
-            contentCache.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}`;
-                contentCache.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 };
-}
-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 };
-}
-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 };
-}
-export function parseDisabledPlugins(output) {
-    const disabled = new Set();
-    if (!output)
-        return disabled;
-    let currentName = null;
-    for (const line of output.split('\n')) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith('\u276f')) {
-            const full = trimmed.split('\u276f')[1]?.trim() || '';
-            // Format: sub-plugin@marketplace — extract marketplace name for cache dir matching
-            currentName = full.includes('@') ? full.split('@')[1] : full;
-        }
-        else if (trimmed.toLowerCase().includes('disabled') && currentName) {
-            disabled.add(currentName);
-            currentName = null;
-        }
-        else if (trimmed.toLowerCase().includes('enabled')) {
-            currentName = null;
-        }
-    }
-    return disabled;
-}
-async function getDisabledPlugins() {
-    return parseDisabledPlugins(await runCommand('claude plugin list'));
-}
-export function parseClaudeMdSections(content) {
-    const sections = [];
-    const lines = content.split('\n');
-    let currentName = null;
-    let currentContent = '';
-    for (const line of lines) {
-        if (line.startsWith('# ')) {
-            if (currentName !== null) {
-                sections.push({
-                    name: currentName,
-                    sizeBytes: Buffer.byteLength(currentContent),
-                    tokens: countTokensCached(currentContent, `claude-md-section:${currentName}`),
-                });
-            }
-            else if (currentContent.trim()) {
-                sections.push({
-                    name: '(preamble)',
-                    sizeBytes: Buffer.byteLength(currentContent),
-                    tokens: countTokensCached(currentContent, 'claude-md-section:preamble'),
-                });
-            }
-            currentName = line.slice(2).trim().slice(0, 60);
-            currentContent = line + '\n';
-        }
-        else {
-            currentContent += line + '\n';
-        }
-    }
-    if (currentName !== null) {
-        sections.push({
-            name: currentName,
-            sizeBytes: Buffer.byteLength(currentContent),
-            tokens: countTokensCached(currentContent, `claude-md-section:${currentName}`),
-        });
-    }
-    else if (currentContent.trim()) {
-        sections.push({
-            name: '(preamble)',
-            sizeBytes: Buffer.byteLength(currentContent),
-            tokens: countTokensCached(currentContent, 'claude-md-section:preamble'),
-        });
-    }
-    return sections;
-}
-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: [] };
-    }
-}
-function classifyIssues(localSkills, pluginSkills, brokenSymlinks, memoryFiles, tempCaches, staleProjects, disabledPlugins, plugins) {
-    const issues = [];
-    const pluginSkillNames = new Set(pluginSkills.map((s) => s.name));
-    // Tier 1: broken symlinks
-    for (const link of brokenSymlinks) {
-        issues.push({
-            type: 'broken_symlink',
-            tier: 1,
-            name: link.name,
-            detail: link.target,
-            tokens: 0,
-            path: link.path,
-        });
-    }
-    for (const skill of localSkills) {
-        const skillMdPath = join(skill.path, 'SKILL.md');
-        // Tier 1: template skills (use cached content instead of re-reading)
-        const content = contentCache.get(skillMdPath);
-        if (content && content.includes('Replace with description')) {
-            issues.push({
-                type: 'template',
-                tier: 1,
-                name: skill.name,
-                tokens: skill.tokens,
-                path: skill.path,
-            });
-        }
-        // Tier 2: duplicates (local + plugin) — check base name for nested skills
-        const baseName = skill.name.includes('/') ? skill.name.split('/').pop() : skill.name;
-        if (pluginSkillNames.has(baseName)) {
-            issues.push({
-                type: 'duplicate',
-                tier: 2,
-                name: skill.name,
-                detail: 'local+plugin',
-                tokens: skill.tokens,
-                path: skill.path,
-            });
-        }
-        // Tier 3: oversized skills
-        if (skill.sizeBytes > OVERSIZED_SKILL_BYTES) {
-            issues.push({
-                type: 'oversized_skill',
-                tier: 3,
-                name: skill.name,
-                detail: `${Math.round(skill.sizeBytes / 1024)}KB`,
-                tokens: skill.tokens,
-                path: skill.path,
-            });
-        }
-    }
-    // Tier 1: .skill/ duplicate directories
-    for (const skill of localSkills) {
-        const dotSkillDir = skill.path + '.skill';
-        if (localSkills.some((s) => s.path === dotSkillDir)) {
-            issues.push({
-                type: 'skill_dup',
-                tier: 1,
-                name: skill.name,
-                tokens: 0,
-                path: dotSkillDir,
-            });
-        }
-    }
-    // Tier 1: temp_local_* cache directories
-    for (const temp of tempCaches) {
-        issues.push({
-            type: 'temp_cache',
-            tier: 1,
-            name: temp.name,
-            detail: `${temp.sizeKB}KB`,
-            tokens: 0,
-            path: temp.path,
-        });
-    }
-    // Tier 2: oversized memory files
-    for (const mem of memoryFiles) {
-        if (mem.sizeBytes > OVERSIZED_MEMORY_BYTES) {
-            issues.push({
-                type: 'oversized_memory',
-                tier: 2,
-                name: `${mem.project}/${mem.name}`,
-                detail: `${Math.round(mem.sizeBytes / 1024)}KB`,
-                tokens: mem.tokens,
-                path: mem.path,
-            });
-        }
-    }
-    // Tier 2: stale project memory (90+ days inactive)
-    for (const stale of staleProjects) {
-        const memTokens = memoryFiles
-            .filter((m) => m.project === stale.project)
-            .reduce((sum, m) => sum + m.tokens, 0);
-        issues.push({
-            type: 'stale_project',
-            tier: 2,
-            name: stale.project,
-            detail: `${stale.ageDays}d, ${stale.fileCount} files, ${Math.round(stale.totalBytes / 1024)}KB`,
-            tokens: memTokens,
-            path: stale.path,
-        });
-    }
-    // Tier 2: disabled plugins still occupying cache
-    for (const plugin of plugins) {
-        if (disabledPlugins.has(plugin.name)) {
-            issues.push({
-                type: 'disabled_plugin',
-                tier: 2,
-                name: plugin.name,
-                detail: `${plugin.skillCount} skills`,
-                tokens: plugin.skillCount * SKILL_PROMPT_OVERHEAD_TOKENS,
-                path: join(getPluginsDir(), plugin.name),
-            });
-        }
-    }
-    // Sort by tier
-    issues.sort((a, b) => a.tier - b.tier);
-    return issues;
-}
-export async function scan() {
-    contentCache.clear();
-    const [{ skills: localSkills, brokenSymlinks }, { skills: pluginSkills, plugins, tempCaches }, { memoryFiles, staleProjects }, mcp, disabledPlugins,] = await Promise.all([
-        scanLocalSkills(),
-        scanPluginSkills(),
-        scanMemoryFiles(),
-        scanMcpServers(),
-        getDisabledPlugins(),
-    ]);
-    // 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);
-    // 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,
-    };
-}
+// Public barrel — keeps the previously-exported surface stable while the
+// implementation lives in src/scanner/*. External importers (cli.ts, tests,
+// future consumers) do not need to know about the split.
+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';

package/dist/selection.js

@@ -28,9 +28,11 @@ export function resolveRestoreSelection(input, count) {
         return Array.from({ length: count }, (_, i) => i);
     }
     const indices = [];
+    const seen = new Set();
     for (const part of trimmed.split(',')) {
         const num = parseInt(part.trim(), 10);
-        if (!isNaN(num) && num >= 1 && num <= count) {
+        if (!isNaN(num) && num >= 1 && num <= count && !seen.has(num)) {
+            seen.add(num);
             indices.push(num - 1);
         }
     }

package/dist/tokenizer.js

@@ -1,10 +1,13 @@
 import { createHash } from 'node:crypto';
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { readFile, writeFile, mkdir, rename } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { homedir } from 'node:os';
+import { getClaudeDir } from './paths.js';
 let encoder = null;
 let useFallback = false;
-const CACHE_PATH = join(homedir(), '.claude', '.token-cache.json');
+// Resolved lazily so the HOME env stub used in tests is honored.
+function getCachePath() {
+    return join(getClaudeDir(), '.token-cache.json');
+}
 let cache = { version: 1, entries: {} };
 let cacheDirty = false;
 export async function initTokenizer() {
@@ -16,8 +19,12 @@ export async function initTokenizer() {
     catch {
         useFallback = true;
     }
+    // Reset in-memory state so repeated initTokenizer() calls (e.g. across
+    // test cases) don't bleed cache entries from a prior invocation.
+    cache = { version: 1, entries: {} };
+    cacheDirty = false;
     try {
-        const raw = await readFile(CACHE_PATH, 'utf-8');
+        const raw = await readFile(getCachePath(), 'utf-8');
         cache = JSON.parse(raw);
     }
     catch {
@@ -47,9 +54,15 @@ export function countTokensCached(text, filePath) {
 export async function flushCache() {
     if (!cacheDirty)
         return;
+    const target = getCachePath();
+    const tmp = target + '.tmp';
     try {
-        await mkdir(dirname(CACHE_PATH), { recursive: true });
-        await writeFile(CACHE_PATH, JSON.stringify(cache, null, 2));
+        await mkdir(dirname(target), { recursive: true });
+        // Atomic: write to a sibling tmp file first, then rename. A crash mid-write
+        // leaves the prior cache (or nothing) — never a torn JSON file.
+        await writeFile(tmp, JSON.stringify(cache, null, 2));
+        await rename(tmp, target);
+        cacheDirty = false;
     }
     catch {
         // Non-critical

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-slim",
-  "version": "2.2.2",
+  "version": "2.3.0",
   "description": "Analyze and reduce Claude Code token overhead",
   "type": "module",
   "bin": {
@@ -34,6 +34,10 @@
     "type": "git",
     "url": "git+https://github.com/iops-leo/claude-slim.git"
   },
+  "homepage": "https://github.com/iops-leo/claude-slim#readme",
+  "bugs": {
+    "url": "https://github.com/iops-leo/claude-slim/issues"
+  },
   "engines": {
     "node": ">=18"
   },