claude-slim 2.2.2 → 2.3.0

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.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';