claude-slim 2.7.0 → 2.7.1

package/dist/cleaner.js

@@ -1,8 +1,21 @@
 import { rename, readdir, rmdir, rm, unlink, lstat, mkdir } from 'node:fs/promises';
-import { join, dirname } from 'node:path';
+import { join, dirname, resolve, sep } from 'node:path';
 import { appendManifest, ensureDisabledDir, getDisabledDir, removeEntry, recordDisabledPlugin, removeDisabledPlugin } from './manifest.js';
-import { assertInsideClaudeDir, getSkillsDir } from './paths.js';
+import { assertInsideClaudeDir, getSkillsDir, getProjectsDir } from './paths.js';
 import { disablePlugin, enablePlugin } from './plugin-runtime.js';
+// Restrict a restore target to a specific subtree of ~/.claude/. Complements
+// assertInsideClaudeDir: a tampered manifest could still name a legal
+// ~/.claude/ path that belongs to a different type of asset (e.g. redirect a
+// stale-project restore into ~/.claude/skills/ to clobber a skill). By pinning
+// each restore type to its own subtree we close that gap.
+function assertInsideSubtree(p, subtreeRoot, label) {
+    const resolvedTarget = resolve(p);
+    const resolvedRoot = resolve(subtreeRoot);
+    if (resolvedTarget !== resolvedRoot &&
+        !resolvedTarget.startsWith(resolvedRoot + sep)) {
+        throw new Error(`Refusing to restore ${label} outside ${subtreeRoot}: ${p}`);
+    }
+}
 async function pathExists(p) {
     try {
         await lstat(p);
@@ -186,6 +199,11 @@ export async function restoreItem(entry) {
     }
     const disabledDir = getDisabledDir();
     if (legacyEntry.type === 'stale_project') {
+        // Type-scoped path guard: stale-project backups must restore under
+        // ~/.claude/projects/. Prevents a tampered manifest from redirecting a
+        // restore into ~/.claude/skills/ (or elsewhere under ~/.claude/) and
+        // clobbering an unrelated asset.
+        assertInsideSubtree(legacyEntry.from, getProjectsDir(), 'project memory');
         const backupDir = join(disabledDir, 'memory-backup', legacyEntry.name);
         // Refuse to overwrite user's current state
         if (await pathExists(legacyEntry.from)) {
@@ -197,6 +215,8 @@ export async function restoreItem(entry) {
         await rename(backupDir, legacyEntry.from);
     }
     else {
+        // Type-scoped path guard: skill restores must land under ~/.claude/skills/.
+        assertInsideSubtree(legacyEntry.from, getSkillsDir(), 'skill');
         // Restore skill directory using the same naming as cleanIssues
         const safeName = legacyEntry.name.replace(/\//g, '--');
         const src = join(disabledDir, safeName);

package/dist/cli.js

@@ -13,6 +13,17 @@ import { collectDoctorReport, formatDoctorReport } from './doctor.js';
 import { resolveSelection, resolveRestoreSelection } from './selection.js';
 const pkgPath = join(dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
 const { version: PKG_VERSION } = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+// Parse a non-negative-integer CLI option, keeping explicit 0 distinct from an
+// unset/invalid value. `parseInt(x, 10) || N` was swallowing legitimate 0
+// (e.g. `--lookback-days 0` was silently upgraded to 60).
+function parseNonNegativeInt(raw, fallback) {
+    if (typeof raw !== 'string')
+        return fallback;
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isFinite(n) || n < 0)
+        return fallback;
+    return n;
+}
 const program = new Command();
 program
     .name('claude-slim')
@@ -26,7 +37,7 @@ program
     .option('--lookback-days <n>', 'Days of session history for skill-usage analysis', '60')
     .action(async (opts) => {
     await initTokenizer();
-    const result = await scan({ lookbackDays: parseInt(opts.lookbackDays, 10) || 60 });
+    const result = await scan({ lookbackDays: parseNonNegativeInt(opts.lookbackDays, 60) });
     await flushCache();
     if (opts.json) {
         console.log(JSON.stringify(result, null, 2));
@@ -43,7 +54,7 @@ program
     .option('--lookback-days <n>', 'Days of session history for skill-usage analysis', '60')
     .action(async (opts) => {
     const report = await collectDoctorReport({
-        lookbackDays: parseInt(opts.lookbackDays, 10) || 60,
+        lookbackDays: parseNonNegativeInt(opts.lookbackDays, 60),
     });
     if (opts.json) {
         console.log(JSON.stringify(report, null, 2));
@@ -64,8 +75,8 @@ program
     await runCleanPipeline({
         dryRun: !!opts.dryRun,
         auto: !!opts.auto,
-        sessionsPerDay: parseInt(opts.sessionsPerDay, 10) || 2,
-        lookbackDays: parseInt(opts.lookbackDays, 10) || 60,
+        sessionsPerDay: parseNonNegativeInt(opts.sessionsPerDay, 2),
+        lookbackDays: parseNonNegativeInt(opts.lookbackDays, 60),
     });
 });
 // --- restore ---
@@ -151,17 +162,21 @@ program
     .option('--lookback-days <n>', 'Days of session history for skill-usage analysis', '60')
     .action(async (opts) => {
     await initTokenizer();
-    const result = await scan({ lookbackDays: parseInt(opts.lookbackDays, 10) || 60 });
+    const result = await scan({ lookbackDays: parseNonNegativeInt(opts.lookbackDays, 60) });
     const allEntries = await readManifest();
     // Filter to legacy-style entries only (those with tokenCount/name/from fields)
     const entries = allEntries.filter((e) => !('plugin' in e && 'marketplace' in e));
-    const movedEntries = entries.filter((e) => e.tokenCount && e.tokenCount > 0);
+    // Any prior manifest entry counts as a cleanup receipt. Filtering on
+    // `tokenCount > 0` previously hid runs that only removed zero-token items
+    // (broken_symlink / temp_cache), making `report` say "no previous cleanup"
+    // even after real work.
+    const movedEntries = entries;
     if (movedEntries.length === 0) {
         console.log('\n  No previous cleanup found. Run `claude-slim clean` first.\n');
         await flushCache();
         return;
     }
-    const sessionsPerDay = parseInt(opts.sessionsPerDay, 10) || 2;
+    const sessionsPerDay = parseNonNegativeInt(opts.sessionsPerDay, 2);
     // Reconstruct "before" state: current + what was removed.
     // Only skill-type entries contributed to the per-skill prompt overhead
     // (stale_project restores memory tokens separately; broken_symlink/
@@ -222,15 +237,20 @@ async function runCleanPipeline(opts) {
         const selection = await askUser('  Your choice: ');
         selectedIssues = resolveSelection(selection, result.issues);
     }
-    else {
-        // Auto mode or non-TTY: select Tier 1 only
+    else if (opts.auto) {
+        // Explicit non-interactive mode: select Tier 1 only.
         selectedIssues = result.issues.filter((i) => i.tier === 1);
-        if (!opts.auto) {
-            console.log('  \x1b[33m⚠ Non-interactive mode detected, auto-selecting Tier 1\x1b[0m\n');
-        }
-        else {
-            console.log(`  \x1b[36m→ Auto mode: selecting ${selectedIssues.length} Tier 1 item(s)\x1b[0m\n`);
-        }
+        console.log(`  \x1b[36m→ Auto mode: selecting ${selectedIssues.length} Tier 1 item(s)\x1b[0m\n`);
+    }
+    else {
+        // Non-TTY without --auto/--dry-run: refuse rather than silently mutating
+        // the filesystem. Prior behavior auto-selected Tier 1, which surprised
+        // users who ran the CLI from scripts/nohup expecting a no-op.
+        console.log('\n  \x1b[33m⚠ Non-interactive shell detected.\x1b[0m ' +
+            'Re-run with \x1b[1m--auto\x1b[0m (apply Tier 1) or \x1b[1m--dry-run\x1b[0m (preview only).\n');
+        await flushCache();
+        process.exitCode = 1;
+        return;
     }
     if (selectedIssues.length === 0) {
         console.log('\n  Cancelled. No changes made.\n');

package/dist/scanner/detectors.d.ts

@@ -24,6 +24,7 @@ export interface DetectorContext {
     recentCommands: Set<string>;
     totalUserCallableInvocations: number;
     sessionsInWindow: number;
+    pluginCosts: Map<string, number>;
 }
 export interface Detector {
     name: string;

package/dist/scanner/detectors.js

@@ -40,9 +40,11 @@ const duplicateDetector = {
         const pluginSkillNames = new Set(pluginSkills.map((s) => s.name));
         const issues = [];
         for (const skill of localSkills) {
-            // Check base name for nested skills (e.g. "org/ship" → "ship")
-            const baseName = skill.name.includes('/') ? skill.name.split('/').pop() : skill.name;
-            if (pluginSkillNames.has(baseName)) {
+            // Exact-name match only. A prior baseName fallback flagged nested local
+            // skills (e.g. `org/ship`) as duplicates of a bare plugin `ship`, but
+            // namespaced local skills are addressable independently and are not real
+            // duplicates — the fallback risked disabling user content.
+            if (pluginSkillNames.has(skill.name)) {
                 issues.push({
                     type: 'duplicate',
                     tier: 2,
@@ -177,7 +179,7 @@ const unusedSkillDetector = {
 };
 const unusedPluginDetector = {
     name: 'unused_plugin',
-    detect({ pluginSurfaces, enabledPlugins, recentSkillInvocations, recentMcpPrefixes, recentCommands, totalUserCallableInvocations, sessionsInWindow, lookbackDays, }) {
+    detect({ pluginSurfaces, enabledPlugins, recentSkillInvocations, recentMcpPrefixes, recentCommands, totalUserCallableInvocations, sessionsInWindow, lookbackDays, pluginCosts, }) {
         // (a) Global suppression: too few sessions to draw a conclusion
         if (sessionsInWindow < 3)
             return [];
@@ -211,7 +213,7 @@ const unusedPluginDetector = {
                 name: ps.pluginName,
                 marketplace: ps.marketplace,
                 detail: `not invoked in ${lookbackDays}d (${ps.marketplace})`,
-                tokens: 0,
+                tokens: pluginCosts.get(ps.pluginName) ?? 0,
                 path: ps.installDir,
             });
         }

package/dist/scanner/index.js

@@ -12,6 +12,7 @@ import { scanSessionUsage } from './sessions.js';
 import { classifyIssues } from './detectors.js';
 import { scanPluginSurfaces } from './plugin-surfaces.js';
 import { computePluginBreakdown } from './plugin-breakdown.js';
+import { computePluginCosts } from './plugin-cost.js';
 import { SKILL_PROMPT_OVERHEAD_TOKENS } from './constants.js';
 const DEFAULT_LOOKBACK_DAYS = 60;
 export async function scan(opts = {}) {
@@ -44,6 +45,14 @@ export async function scan(opts = {}) {
         ? countTokensCached(claudeMdContent, join(getClaudeDir(), 'CLAUDE.md'))
         : 0;
     const claudeMdSections = claudeMdContent ? parseClaudeMdSections(claudeMdContent) : [];
+    // Per-plugin cost map for the unused_plugin detector's savings estimate.
+    // Aggregates when multiple surface entries share a pluginName (mirrors the
+    // same logic in computePluginBreakdown).
+    const pluginCostBreakdowns = computePluginCosts(pluginSurfaces, claudeMdSections);
+    const pluginCosts = new Map();
+    for (const c of pluginCostBreakdowns) {
+        pluginCosts.set(c.pluginName, (pluginCosts.get(c.pluginName) ?? 0) + c.totalEstimatedTokens);
+    }
     const issues = classifyIssues({
         localSkills, pluginSkills, brokenSymlinks, memoryFiles,
         tempCaches, staleProjects, disabledPlugins, plugins,
@@ -57,6 +66,7 @@ export async function scan(opts = {}) {
         recentCommands: sessionUsage.commandsInvoked,
         totalUserCallableInvocations: sessionUsage.totalUserCallableInvocations,
         sessionsInWindow: sessionUsage.sessionsInWindow,
+        pluginCosts,
     });
     // Compute plugin breakdown (used by PLUGINS table in scan output)
     const pluginBreakdown = computePluginBreakdown({

package/dist/scanner/sessions.js

@@ -130,9 +130,12 @@ export function extractMcpPrefixesFromTranscript(content) {
 //
 // 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 TAG_RE = /<command-name>([^<]+)<\/command-name>/g;
     const lines = content.split('\n');
     for (const line of lines) {
         if (!line)
@@ -170,9 +173,7 @@ export function extractCommandsFromTranscript(content) {
             }
         }
         for (const text of texts) {
-            TAG_RE.lastIndex = 0;
-            let match;
-            while ((match = TAG_RE.exec(text)) !== null) {
+            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);

package/package.json

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