skill-analyzer 0.1.2 → 0.1.3

package/dist/args.d.ts

@@ -0,0 +1,10 @@
+import { type Locale } from "./locale/index.js";
+export interface ParsedArgs {
+    skillsDir: string;
+    logsDir: string;
+    days?: number;
+    json: boolean;
+    locale: Locale;
+    help: boolean;
+}
+export declare function parseArgs(args: string[]): ParsedArgs;

package/dist/args.js

@@ -0,0 +1,24 @@
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { getLocale } from "./locale/index.js";
+const SUPPORTED_LANGS = ["en", "ja"];
+export function parseArgs(args) {
+    const rawLang = stringFlag(args, "--lang") ?? "en";
+    const lang = SUPPORTED_LANGS.includes(rawLang) ? rawLang : "en";
+    return {
+        skillsDir: stringFlag(args, "--skills-dir") ?? join(homedir(), ".claude", "skills"),
+        logsDir: stringFlag(args, "--logs-dir") ?? join(homedir(), ".claude", "projects"),
+        days: intFlag(args, "--days"),
+        json: args.includes("--json"),
+        locale: getLocale(lang),
+        help: args.includes("--help"),
+    };
+}
+function stringFlag(args, flag) {
+    const idx = args.indexOf(flag);
+    return idx !== -1 && args[idx + 1] ? args[idx + 1] : undefined;
+}
+function intFlag(args, flag) {
+    const val = stringFlag(args, flag);
+    return val !== undefined ? parseInt(val, 10) : undefined;
+}

package/dist/budget.d.ts

@@ -1,3 +1,17 @@
+import type { ParsedArgs } from "./args.js";
+import { type SkillEntry } from "./registry.js";
 export declare const OVERHEAD_PER_SKILL = 109;
 export declare const FALLBACK_BUDGET = 16000;
-export declare function budgetCommand(args: string[]): void;
+export interface BudgetEntry {
+    name: string;
+    descriptionLength: number;
+    totalChars: number;
+}
+export interface BudgetResult {
+    budget: number;
+    isFallback: boolean;
+    totalUsed: number;
+    entries: BudgetEntry[];
+}
+export declare function computeBudget(registry: SkillEntry[]): BudgetResult;
+export declare function budgetCommand(args: ParsedArgs, registry?: SkillEntry[]): void;

package/dist/budget.js

@@ -1,16 +1,13 @@
 import chalk from "chalk";
-import { getSkillsDir, loadSkillRegistry } from "./registry.js";
+import { loadSkillRegistry } from "./registry.js";
 import { sectionHeader, keyValue, budgetBar, makeTable } from "./formatter.js";
 export const OVERHEAD_PER_SKILL = 109;
 export const FALLBACK_BUDGET = 16_000;
-export function budgetCommand(args) {
-    const skillsDir = getSkillsDir(args);
-    const skills = loadSkillRegistry(skillsDir);
+export function computeBudget(registry) {
     const envBudget = process.env["SLASH_COMMAND_TOOL_CHAR_BUDGET"];
     const budget = parseInt(envBudget ?? String(FALLBACK_BUDGET), 10);
     const isFallback = !envBudget;
-    const isJson = args.includes("--json");
-    const entries = skills
+    const entries = registry
         .map((s) => ({
         name: s.name,
         descriptionLength: s.descriptionLength,
@@ -18,35 +15,41 @@ export function budgetCommand(args) {
     }))
         .sort((a, b) => b.totalChars - a.totalChars);
     const totalUsed = entries.reduce((sum, e) => sum + e.totalChars, 0);
-    if (isJson) {
+    return { budget, isFallback, totalUsed, entries };
+}
+export function budgetCommand(args, registry) {
+    const t = args.locale;
+    const skills = registry ?? loadSkillRegistry(args.skillsDir);
+    const { budget, isFallback, totalUsed, entries } = computeBudget(skills);
+    if (args.json) {
         console.log(JSON.stringify({ budget, isFallback, totalUsed, entries }, null, 2));
         return;
     }
     const overBudget = totalUsed > budget;
-    sectionHeader("Description Budget", overBudget ? "OVER BUDGET" : undefined);
+    sectionHeader(t.budgetTitle, overBudget ? t.overBudget : undefined);
     keyValue([
-        ["Budget:", budgetBar(totalUsed, budget)],
+        [t.budgetLabel, budgetBar(totalUsed, budget)],
         [
-            "Used:",
-            `${totalUsed.toLocaleString()} / ${budget.toLocaleString()} chars`,
+            t.usedLabel,
+            t.usedOf(totalUsed.toLocaleString(), budget.toLocaleString()),
         ],
         [
-            "Remaining:",
+            t.remainingLabel,
             overBudget
-                ? chalk.red(`-${(totalUsed - budget).toLocaleString()} chars`)
-                : chalk.green(`${(budget - totalUsed).toLocaleString()} chars`),
+                ? chalk.red(`-${t.remainingChars((totalUsed - budget).toLocaleString())}`)
+                : chalk.green(t.remainingChars((budget - totalUsed).toLocaleString())),
         ],
-        ["Skills:", `${entries.length} (${OVERHEAD_PER_SKILL} chars overhead each)`],
+        [t.skillsLabel, `${entries.length} (${t.charsOverheadEach(OVERHEAD_PER_SKILL)})`],
     ]);
     makeTable({
-        head: ["#", "Skill", "Description Chars", "Total Chars"],
+        head: [t.headerRank, t.headerSkill, t.headerDescChars, t.headerTotalChars],
         colAligns: ["right", "left", "right", "right"],
         rows: entries.map((e, i) => [i + 1, e.name, e.descriptionLength, e.totalChars]),
     });
     if (isFallback) {
         console.log();
-        console.log(chalk.dim(`  ${budget.toLocaleString()} is a static fallback. The actual budget is determined dynamically by Claude Code.`));
-        console.log(chalk.dim("  See: https://code.claude.com/docs/en/skills#claude-doesnt-see-all-my-skills"));
+        console.log(chalk.dim(`  ${t.fallbackNote(budget.toLocaleString())}`));
+        console.log(chalk.dim(`  ${t.fallbackLink}`));
     }
     console.log();
 }

package/dist/cli.d.ts

@@ -1 +1 @@
-export declare function run(args: string[]): void;
+export declare function run(rawArgs: string[]): void;

package/dist/cli.js

@@ -1,39 +1,29 @@
+import { parseArgs } from "./args.js";
 import { budgetCommand } from "./budget.js";
 import { usageCommand } from "./usage.js";
 import { deadCommand } from "./dead.js";
 import { reportCommand } from "./report.js";
-export function run(args) {
-    const command = args[0] ?? "report";
+export function run(rawArgs) {
+    const command = rawArgs[0] ?? "report";
+    const args = parseArgs(rawArgs.slice(1));
+    if (args.help || command === "--help") {
+        console.log(args.locale.help);
+        return;
+    }
     switch (command) {
         case "budget":
-            budgetCommand(args.slice(1));
+            budgetCommand(args);
             break;
         case "usage":
-            usageCommand(args.slice(1));
+            usageCommand(args);
             break;
         case "dead":
-            deadCommand(args.slice(1));
+            deadCommand(args);
             break;
         case "report":
-            reportCommand(args.slice(1));
+            reportCommand(args);
             break;
         default:
-            printHelp();
+            console.log(args.locale.help);
     }
 }
-function printHelp() {
-    console.log(`skill-analyzer - Analyze your Claude Code skill library
-
-Usage: skill-analyzer <command> [options]
-
-Commands:
-  report    Full analysis report (default)
-  usage     Skill usage frequency
-  dead      Unused skills
-  budget    Description budget consumption
-
-Options:
-  --skills-dir <path>  Skills directory (default: ~/.claude/skills)
-  --json               Output as JSON
-  --help               Show this help`);
-}

package/dist/dead.d.ts

@@ -1 +1,9 @@
-export declare function deadCommand(args: string[]): void;
+import type { ParsedArgs } from "./args.js";
+import { type SkillEntry } from "./registry.js";
+import { type SkillInvocation, type UsageResult } from "./scanner.js";
+export declare function computeDeadSkills(registry: SkillEntry[], usage: UsageResult[]): SkillEntry[];
+export declare function deadCommand(args: ParsedArgs, preloaded?: {
+    registry: SkillEntry[];
+    invocations: SkillInvocation[];
+    usage: UsageResult[];
+}): void;

package/dist/dead.js

@@ -1,41 +1,40 @@
 import chalk from "chalk";
-import { getSkillsDir, loadSkillRegistry } from "./registry.js";
-import { getLogsDir, scanSessions, aggregateUsage } from "./scanner.js";
+import { loadSkillRegistry } from "./registry.js";
+import { scanSessions, aggregateUsage } from "./scanner.js";
 import { sectionHeader, keyValue, makeTable } from "./formatter.js";
 import { OVERHEAD_PER_SKILL } from "./budget.js";
-export function deadCommand(args) {
-    const skillsDir = getSkillsDir(args);
-    const logsDir = getLogsDir(args);
-    const daysIdx = args.indexOf("--days");
-    const days = daysIdx !== -1 ? parseInt(args[daysIdx + 1], 10) : undefined;
-    const isJson = args.includes("--json");
-    const registry = loadSkillRegistry(skillsDir);
-    const invocations = scanSessions(logsDir, days);
-    const usage = aggregateUsage(invocations);
+export function computeDeadSkills(registry, usage) {
     const usedSkills = new Set(usage.map((u) => u.skill));
-    const deadSkills = registry.filter((s) => !usedSkills.has(s.name));
-    if (isJson) {
+    return registry.filter((s) => !usedSkills.has(s.name));
+}
+export function deadCommand(args, preloaded) {
+    const t = args.locale;
+    const registry = preloaded?.registry ?? loadSkillRegistry(args.skillsDir);
+    const invocations = preloaded?.invocations ?? scanSessions(args.logsDir, args.days);
+    const usage = preloaded?.usage ?? aggregateUsage(invocations);
+    const deadSkills = computeDeadSkills(registry, usage);
+    if (args.json) {
         console.log(JSON.stringify({ deadSkills: deadSkills.map((s) => s.name), count: deadSkills.length }, null, 2));
         return;
     }
-    const period = days ? `last ${days} days` : "all time";
-    sectionHeader(`Dead Skills (${period})`);
+    const period = args.days ? t.periodDays(args.days) : t.periodAll;
+    sectionHeader(t.deadTitle(period));
     const totalWaste = deadSkills.reduce((sum, s) => sum + s.descriptionLength + OVERHEAD_PER_SKILL, 0);
     keyValue([
-        ["Dead:", `${deadSkills.length} of ${registry.length} local skills`],
+        [t.deadLabel, t.deadOf(deadSkills.length, registry.length)],
         [
-            "Savings:",
+            t.savingsLabel,
             deadSkills.length > 0
-                ? chalk.yellow(`${totalWaste.toLocaleString()} chars recoverable`)
-                : chalk.green("None needed"),
+                ? chalk.yellow(t.charsRecoverable(totalWaste.toLocaleString()))
+                : chalk.green(t.noneNeeded),
         ],
     ]);
     if (deadSkills.length === 0) {
-        console.log(chalk.green("  All skills have been used at least once.\n"));
+        console.log(chalk.green(`  ${t.allUsed}\n`));
         return;
     }
     makeTable({
-        head: ["#", "Skill", "Description Chars", "Total Chars"],
+        head: [t.headerRank, t.headerSkill, t.headerDescChars, t.headerTotalChars],
         colAligns: ["right", "left", "right", "right"],
         rows: deadSkills.map((s, i) => [
             i + 1,

package/dist/formatter.js

@@ -15,7 +15,7 @@ export function keyValue(pairs) {
 export function budgetBar(used, total) {
     const pct = used / total;
     const width = 30;
-    const filled = Math.round(pct * width);
+    const filled = Math.min(Math.round(pct * width), width);
     const empty = width - filled;
     const color = pct > 1 ? chalk.red : pct > 0.7 ? chalk.yellow : chalk.green;
     const bar = color("█".repeat(filled)) + chalk.dim("░".repeat(empty));

package/dist/locale/en.d.ts

@@ -0,0 +1,2 @@
+import type { Locale } from "./types.js";
+export declare const en: Locale;

package/dist/locale/en.js

@@ -0,0 +1,54 @@
+export const en = {
+    // budget
+    budgetTitle: "Description Budget",
+    overBudget: "OVER BUDGET",
+    budgetLabel: "Budget:",
+    usedLabel: "Used:",
+    remainingLabel: "Remaining:",
+    skillsLabel: "Skills:",
+    charsOverheadEach: (n) => `${n} chars overhead each`,
+    usedOf: (used, total) => `${used} / ${total} chars`,
+    remainingChars: (n) => `${n} chars`,
+    fallbackNote: (budget) => `${budget} is a static fallback. The actual budget is determined dynamically by Claude Code.`,
+    fallbackLink: "See: https://code.claude.com/docs/en/skills#claude-doesnt-see-all-my-skills",
+    // dead
+    deadTitle: (period) => `Dead Skills (${period})`,
+    deadLabel: "Dead:",
+    deadOf: (dead, total) => `${dead} of ${total} local skills`,
+    savingsLabel: "Savings:",
+    charsRecoverable: (n) => `${n} chars recoverable`,
+    noneNeeded: "None needed",
+    allUsed: "All skills have been used at least once.",
+    // usage
+    usageTitle: (period) => `Skill Usage (${period})`,
+    invocationsLabel: "Invocations:",
+    uniqueSkillsLabel: "Unique skills:",
+    noInvocations: "No skill invocations found.",
+    // period
+    periodAll: "all time",
+    periodDays: (days) => `last ${days} days`,
+    // table headers
+    headerRank: "#",
+    headerSkill: "Skill",
+    headerDescChars: "Description Chars",
+    headerTotalChars: "Total Chars",
+    headerCount: "Count",
+    headerLastUsed: "Last Used",
+    unknown: "unknown",
+    // help
+    help: `skill-analyzer - Analyze your Claude Code skill library
+
+Usage: skill-analyzer <command> [options]
+
+Commands:
+  report    Full analysis report (default)
+  usage     Skill usage frequency
+  dead      Unused skills
+  budget    Description budget consumption
+
+Options:
+  --skills-dir <path>  Skills directory (default: ~/.claude/skills)
+  --lang <en|ja>       Output language (default: en)
+  --json               Output as JSON
+  --help               Show this help`,
+};

package/dist/locale/index.d.ts

@@ -0,0 +1,3 @@
+import type { Locale, Lang } from "./types.js";
+export declare function getLocale(lang: Lang): Locale;
+export type { Locale, Lang };

package/dist/locale/index.js

@@ -0,0 +1,6 @@
+import { en } from "./en.js";
+import { ja } from "./ja.js";
+const locales = { en, ja };
+export function getLocale(lang) {
+    return locales[lang];
+}

package/dist/locale/ja.d.ts

@@ -0,0 +1,2 @@
+import type { Locale } from "./types.js";
+export declare const ja: Locale;

package/dist/locale/ja.js

@@ -0,0 +1,54 @@
+export const ja = {
+    // budget
+    budgetTitle: "説明文バジェット",
+    overBudget: "超過",
+    budgetLabel: "バジェット:",
+    usedLabel: "使用量:",
+    remainingLabel: "残り:",
+    skillsLabel: "スキル数:",
+    charsOverheadEach: (n) => `各スキル ${n} 文字のオーバーヘッド`,
+    usedOf: (used, total) => `${used} / ${total} 文字`,
+    remainingChars: (n) => `${n} 文字`,
+    fallbackNote: (budget) => `${budget} は静的なフォールバック値です。実際のバジェットは Claude Code が動的に決定します。`,
+    fallbackLink: "参照: https://code.claude.com/docs/en/skills#claude-doesnt-see-all-my-skills",
+    // dead
+    deadTitle: (period) => `未使用スキル (${period})`,
+    deadLabel: "未使用:",
+    deadOf: (dead, total) => `${total} 件中 ${dead} 件`,
+    savingsLabel: "削減可能:",
+    charsRecoverable: (n) => `${n} 文字を回収可能`,
+    noneNeeded: "不要",
+    allUsed: "すべてのスキルが1回以上使用されています。",
+    // usage
+    usageTitle: (period) => `スキル使用状況 (${period})`,
+    invocationsLabel: "呼び出し回数:",
+    uniqueSkillsLabel: "ユニークスキル数:",
+    noInvocations: "スキルの呼び出し履歴が見つかりません。",
+    // period
+    periodAll: "全期間",
+    periodDays: (days) => `直近 ${days} 日`,
+    // table headers
+    headerRank: "#",
+    headerSkill: "スキル",
+    headerDescChars: "説明文字数",
+    headerTotalChars: "合計文字数",
+    headerCount: "回数",
+    headerLastUsed: "最終使用日",
+    unknown: "不明",
+    // help
+    help: `skill-analyzer - Claude Code スキルライブラリの分析ツール
+
+使い方: skill-analyzer <コマンド> [オプション]
+
+コマンド:
+  report    全体レポート（デフォルト）
+  usage     スキル使用頻度
+  dead      未使用スキル
+  budget    説明文バジェット消費量
+
+オプション:
+  --skills-dir <パス>  スキルディレクトリ（デフォルト: ~/.claude/skills）
+  --lang <en|ja>       出力言語（デフォルト: en）
+  --json               JSON形式で出力
+  --help               このヘルプを表示`,
+};

package/dist/locale/types.d.ts

@@ -0,0 +1,35 @@
+export type Lang = "en" | "ja";
+export interface Locale {
+    budgetTitle: string;
+    overBudget: string;
+    budgetLabel: string;
+    usedLabel: string;
+    remainingLabel: string;
+    skillsLabel: string;
+    charsOverheadEach: (n: number) => string;
+    usedOf: (used: string, total: string) => string;
+    remainingChars: (n: string) => string;
+    fallbackNote: (budget: string) => string;
+    fallbackLink: string;
+    deadTitle: (period: string) => string;
+    deadLabel: string;
+    deadOf: (dead: number, total: number) => string;
+    savingsLabel: string;
+    charsRecoverable: (n: string) => string;
+    noneNeeded: string;
+    allUsed: string;
+    usageTitle: (period: string) => string;
+    invocationsLabel: string;
+    uniqueSkillsLabel: string;
+    noInvocations: string;
+    periodAll: string;
+    periodDays: (days: number) => string;
+    headerRank: string;
+    headerSkill: string;
+    headerDescChars: string;
+    headerTotalChars: string;
+    headerCount: string;
+    headerLastUsed: string;
+    unknown: string;
+    help: string;
+}

package/dist/locale/types.js

@@ -0,0 +1 @@
+export {};

package/dist/registry.d.ts

@@ -4,5 +4,4 @@ export interface SkillEntry {
     descriptionLength: number;
     path: string;
 }
-export declare function getSkillsDir(args: string[]): string;
 export declare function loadSkillRegistry(skillsDir: string): SkillEntry[];

package/dist/registry.js

@@ -1,13 +1,5 @@
-import { readFileSync, readdirSync, statSync } from "node:fs";
+import { readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import { homedir } from "node:os";
-export function getSkillsDir(args) {
-    const idx = args.indexOf("--skills-dir");
-    if (idx !== -1 && args[idx + 1]) {
-        return args[idx + 1];
-    }
-    return join(homedir(), ".claude", "skills");
-}
 export function loadSkillRegistry(skillsDir) {
     const entries = [];
     let dirs;
@@ -20,13 +12,13 @@ export function loadSkillRegistry(skillsDir) {
     }
     for (const dir of dirs) {
         const skillMdPath = join(skillsDir, dir, "SKILL.md");
+        let content;
         try {
-            statSync(skillMdPath);
+            content = readFileSync(skillMdPath, "utf-8");
         }
         catch {
             continue;
         }
-        const content = readFileSync(skillMdPath, "utf-8");
         const { name, description } = parseFrontmatter(content, dir);
         entries.push({
             name,

package/dist/report.d.ts

@@ -1 +1,2 @@
-export declare function reportCommand(args: string[]): void;
+import type { ParsedArgs } from "./args.js";
+export declare function reportCommand(args: ParsedArgs): void;

package/dist/report.js

@@ -1,43 +1,26 @@
-import { getSkillsDir, loadSkillRegistry } from "./registry.js";
-import { getLogsDir, scanSessions, aggregateUsage } from "./scanner.js";
-import { budgetCommand, OVERHEAD_PER_SKILL, FALLBACK_BUDGET } from "./budget.js";
+import { loadSkillRegistry } from "./registry.js";
+import { scanSessions, aggregateUsage } from "./scanner.js";
+import { computeBudget } from "./budget.js";
+import { computeDeadSkills } from "./dead.js";
+import { budgetCommand } from "./budget.js";
 import { usageCommand } from "./usage.js";
 import { deadCommand } from "./dead.js";
 export function reportCommand(args) {
-    const isJson = args.includes("--json");
-    if (isJson) {
-        reportJson(args);
+    const registry = loadSkillRegistry(args.skillsDir);
+    const invocations = scanSessions(args.logsDir, args.days);
+    const usage = aggregateUsage(invocations);
+    if (args.json) {
+        const deadSkills = computeDeadSkills(registry, usage).map((s) => s.name);
+        const budgetData = computeBudget(registry);
+        console.log(JSON.stringify({
+            usage: { totalInvocations: invocations.length, skills: usage },
+            dead: { count: deadSkills.length, skills: deadSkills },
+            budget: { limit: budgetData.budget, isFallback: budgetData.isFallback, totalUsed: budgetData.totalUsed, entries: budgetData.entries },
+        }, null, 2));
         return;
     }
-    // Just run all three in sequence
-    usageCommand(args);
-    deadCommand(args);
-    budgetCommand(args);
-}
-function reportJson(args) {
-    const skillsDir = getSkillsDir(args);
-    const logsDir = getLogsDir(args);
-    const daysIdx = args.indexOf("--days");
-    const days = daysIdx !== -1 ? parseInt(args[daysIdx + 1], 10) : undefined;
-    const registry = loadSkillRegistry(skillsDir);
-    const invocations = scanSessions(logsDir, days);
-    const usage = aggregateUsage(invocations);
-    const usedSkills = new Set(usage.map((u) => u.skill));
-    const deadSkills = registry.filter((s) => !usedSkills.has(s.name)).map((s) => s.name);
-    const envBudget = process.env["SLASH_COMMAND_TOOL_CHAR_BUDGET"];
-    const budget = parseInt(envBudget ?? String(FALLBACK_BUDGET), 10);
-    const isFallback = !envBudget;
-    const budgetEntries = registry
-        .map((s) => ({
-        name: s.name,
-        descriptionLength: s.descriptionLength,
-        totalChars: s.descriptionLength + OVERHEAD_PER_SKILL,
-    }))
-        .sort((a, b) => b.totalChars - a.totalChars);
-    const totalUsed = budgetEntries.reduce((sum, e) => sum + e.totalChars, 0);
-    console.log(JSON.stringify({
-        usage: { totalInvocations: invocations.length, skills: usage },
-        dead: { count: deadSkills.length, skills: deadSkills },
-        budget: { limit: budget, isFallback, totalUsed, entries: budgetEntries },
-    }, null, 2));
+    const preloaded = { registry, invocations, usage };
+    usageCommand(args, preloaded);
+    deadCommand(args, preloaded);
+    budgetCommand(args, registry);
 }

package/dist/scanner.d.ts

@@ -8,6 +8,5 @@ export interface UsageResult {
     count: number;
     lastUsed: string;
 }
-export declare function getLogsDir(args: string[]): string;
 export declare function scanSessions(logsDir: string, daysLimit?: number): SkillInvocation[];
 export declare function aggregateUsage(invocations: SkillInvocation[]): UsageResult[];

package/dist/scanner.js

@@ -1,14 +1,6 @@
 import { readFileSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { homedir } from "node:os";
 import { normalizeSkillName } from "./normalizer.js";
-export function getLogsDir(args) {
-    const idx = args.indexOf("--logs-dir");
-    if (idx !== -1 && args[idx + 1]) {
-        return args[idx + 1];
-    }
-    return join(homedir(), ".claude", "projects");
-}
 export function scanSessions(logsDir, daysLimit) {
     const invocations = [];
     const cutoff = daysLimit

package/dist/usage.d.ts

@@ -1 +1,6 @@
-export declare function usageCommand(args: string[]): void;
+import type { ParsedArgs } from "./args.js";
+import { type SkillInvocation, type UsageResult } from "./scanner.js";
+export declare function usageCommand(args: ParsedArgs, preloaded?: {
+    invocations: SkillInvocation[];
+    usage: UsageResult[];
+}): void;

package/dist/usage.js

@@ -1,35 +1,32 @@
 import chalk from "chalk";
-import { getLogsDir, scanSessions, aggregateUsage } from "./scanner.js";
+import { scanSessions, aggregateUsage } from "./scanner.js";
 import { sectionHeader, keyValue, makeTable } from "./formatter.js";
-export function usageCommand(args) {
-    const logsDir = getLogsDir(args);
-    const daysIdx = args.indexOf("--days");
-    const days = daysIdx !== -1 ? parseInt(args[daysIdx + 1], 10) : undefined;
-    const isJson = args.includes("--json");
-    const invocations = scanSessions(logsDir, days);
-    const usage = aggregateUsage(invocations);
-    if (isJson) {
+export function usageCommand(args, preloaded) {
+    const t = args.locale;
+    const invocations = preloaded?.invocations ?? scanSessions(args.logsDir, args.days);
+    const usage = preloaded?.usage ?? aggregateUsage(invocations);
+    if (args.json) {
         console.log(JSON.stringify({ totalInvocations: invocations.length, skills: usage }, null, 2));
         return;
     }
-    const period = days ? `last ${days} days` : "all time";
-    sectionHeader(`Skill Usage (${period})`);
+    const period = args.days ? t.periodDays(args.days) : t.periodAll;
+    sectionHeader(t.usageTitle(period));
     keyValue([
-        ["Invocations:", String(invocations.length)],
-        ["Unique skills:", String(usage.length)],
+        [t.invocationsLabel, String(invocations.length)],
+        [t.uniqueSkillsLabel, String(usage.length)],
     ]);
     if (usage.length === 0) {
-        console.log(chalk.dim("  No skill invocations found.\n"));
+        console.log(chalk.dim(`  ${t.noInvocations}\n`));
         return;
     }
     makeTable({
-        head: ["#", "Skill", "Count", "Last Used"],
+        head: [t.headerRank, t.headerSkill, t.headerCount, t.headerLastUsed],
         colAligns: ["right", "left", "right", "left"],
         rows: usage.map((u, i) => [
             i + 1,
             u.skill,
             u.count,
-            u.lastUsed ? u.lastUsed.slice(0, 10) : "unknown",
+            u.lastUsed ? u.lastUsed.slice(0, 10) : t.unknown,
         ]),
     });
     console.log();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skill-analyzer",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Analyze Claude Code skill library: usage frequency, dead skills, description budget consumption",
   "type": "module",
   "bin": {