@crafter/skillkit 0.0.1

package/package.json

@@ -0,0 +1,24 @@
+{
+	"name": "@crafter/skillkit",
+	"version": "0.0.1",
+	"type": "module",
+	"bin": {
+		"skill-kit": "./src/bin.ts"
+	},
+	"exports": {
+		".": {
+			"bun": "./src/index.ts",
+			"import": "./src/index.ts"
+		}
+	},
+	"scripts": {
+		"dev": "bun run src/bin.ts",
+		"build": "bun build src/bin.ts --compile --outfile dist/skill-kit",
+		"test": "bun test src/",
+		"type-check": "tsc --noEmit"
+	},
+	"devDependencies": {
+		"@types/bun": "^1.2.14",
+		"typescript": "^5.9.3"
+	}
+}

package/src/bin.ts

@@ -0,0 +1,77 @@
+#!/usr/bin/env bun
+import { bold, cyan, dim, yellow } from "./tui/colors";
+
+const VERSION = "0.0.1";
+
+function printHelp(): void {
+	console.log(`
+  ${bold("skill-kit")} ${dim(`v${VERSION}`)} - Claude skill analytics & management
+
+  ${bold("USAGE")}
+    skill-kit <command>
+
+  ${bold("COMMANDS")}
+    ${cyan("list")}      List all installed skills
+    ${cyan("stats")}     Show usage analytics (last 30 days)
+    ${cyan("health")}    Run a health check on your skill setup
+    ${cyan("analyze")}   Scan sessions and populate analytics DB
+    ${cyan("version")}   Print version
+    ${cyan("help")}      Show this help message
+`);
+}
+
+async function main(): Promise<void> {
+	const cmd = process.argv[2];
+
+	switch (cmd) {
+		case "list": {
+			const { runList } = await import("./commands/list");
+			runList();
+			break;
+		}
+		case "stats": {
+			const { runStats } = await import("./commands/stats");
+			await runStats();
+			break;
+		}
+		case "health": {
+			const { runHealth } = await import("./commands/health");
+			await runHealth();
+			break;
+		}
+		case "analyze": {
+			const { getDb } = await import("./db/schema");
+			const { scanAllSessions } = await import("./scanner/index");
+			const db = getDb();
+			console.log("\n  Scanning ~/.claude/projects/ for skill invocations...");
+			const count = await scanAllSessions(db);
+			console.log(
+				`  ${count > 0 ? `Found ${count} new invocations.` : "No new invocations found."}\n`,
+			);
+			break;
+		}
+		case "version":
+		case "--version":
+		case "-v": {
+			console.log(VERSION);
+			break;
+		}
+		case "help":
+		case "--help":
+		case "-h":
+		case undefined: {
+			printHelp();
+			break;
+		}
+		default: {
+			console.error(`\n  ${yellow(`Unknown command: ${cmd}`)}`);
+			printHelp();
+			process.exit(1);
+		}
+	}
+}
+
+main().catch((err) => {
+	console.error(err);
+	process.exit(1);
+});

package/src/commands/health.ts

@@ -0,0 +1,128 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getTopSkills } from "../db/queries";
+import { getDb } from "../db/schema";
+import { scanInstalledSkills } from "../scanner/skills";
+import { bold, dim, green, yellow } from "../tui/colors";
+import { healthGauge } from "../tui/health";
+
+const CONTEXT_BUDGET = 16000;
+
+function check(label: string) {
+	return `  ${green("✓")} ${label}`;
+}
+
+function warn(label: string) {
+	return `  ${yellow("⚠")} ${label}`;
+}
+
+function info(label: string) {
+	return `  ${dim("●")} ${label}`;
+}
+
+function _formatSize(bytes: number): string {
+	if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${bytes} B`;
+}
+
+export async function runHealth(): Promise<void> {
+	const skills = scanInstalledSkills();
+	const _skillsDir = join(homedir(), ".claude", "skills");
+	const dbPath = join(homedir(), ".skill-kit", "analytics.db");
+	const dbExists = existsSync(dbPath);
+
+	let totalContextChars = 0;
+	for (const skill of skills) {
+		const skillMdPath = join(skill.path, "SKILL.md");
+		if (existsSync(skillMdPath)) {
+			try {
+				const content = readFileSync(skillMdPath, "utf-8");
+				totalContextChars += content.length;
+			} catch {}
+		}
+	}
+
+	let eventCount = 0;
+	let neverUsed: string[] = [];
+	let hasDbData = false;
+
+	if (dbExists) {
+		const db = getDb();
+		const row = db
+			.query<{ count: number }, []>(
+				"SELECT COUNT(*) as count FROM skill_invocations",
+			)
+			.get();
+		eventCount = row?.count ?? 0;
+		hasDbData = eventCount > 0;
+
+		if (hasDbData) {
+			const topSkills = getTopSkills(db, 365);
+			const usedNames = new Set(topSkills.map((s) => s.skill_name));
+			neverUsed = skills
+				.filter((s) => !usedNames.has(s.name))
+				.map((s) => s.name);
+		}
+	}
+
+	const contextPct = Math.min(
+		100,
+		Math.round((totalContextChars / CONTEXT_BUDGET) * 100),
+	);
+	const usedContextKb = (totalContextChars / 1000).toFixed(1);
+	const budgetKb = (CONTEXT_BUDGET / 1000).toFixed(1);
+
+	console.log(`\n  ${bold("SKILL-KIT HEALTH REPORT")}\n`);
+
+	console.log(check(`${skills.length} skills installed`));
+
+	if (dbExists && hasDbData) {
+		console.log(
+			check(`Analytics DB: ${eventCount.toLocaleString()} events tracked`),
+		);
+	} else if (dbExists) {
+		console.log(warn("Analytics DB exists but has no data"));
+		console.log(dim("    Run: skill-kit stats"));
+	} else {
+		console.log(warn("Analytics DB not found"));
+		console.log(dim("    Run: skill-kit stats"));
+	}
+
+	if (neverUsed.length > 0) {
+		console.log();
+		console.log(warn(`${neverUsed.length} skills never used`));
+		const preview = neverUsed.slice(0, 5).join(", ");
+		const more = neverUsed.length > 5 ? ` +${neverUsed.length - 5} more` : "";
+		console.log(`    ${dim(preview + more)}`);
+		console.log(`    ${dim("Run: skill-kit uninstall <name>")}`);
+	}
+
+	const unusedContextChars = neverUsed.reduce((acc, name) => {
+		const skill = skills.find((s) => s.name === name);
+		if (!skill) return acc;
+		const skillMdPath = join(skill.path, "SKILL.md");
+		if (!existsSync(skillMdPath)) return acc;
+		try {
+			return acc + readFileSync(skillMdPath, "utf-8").length;
+		} catch {
+			return acc;
+		}
+	}, 0);
+
+	console.log();
+	const gaugeStr = healthGauge(100 - contextPct);
+	console.log(
+		info(
+			`Context budget: ${contextPct}% consumed (${usedContextKb}K / ${budgetKb}K chars)`,
+		),
+	);
+	console.log(`    ${gaugeStr}`);
+	if (unusedContextChars > 0) {
+		console.log(
+			`    ${dim(`${neverUsed.length} unused skills waste ~${(unusedContextChars / 1000).toFixed(1)}K chars`)}`,
+		);
+	}
+
+	console.log();
+}

package/src/commands/list.ts

@@ -0,0 +1,46 @@
+import { scanInstalledSkills } from "../scanner/skills";
+import { bold, cyan, dim } from "../tui/colors";
+
+function formatSize(bytes: number): string {
+	if (bytes >= 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+	if (bytes >= 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${bytes} B`;
+}
+
+function truncate(s: string, max: number): string {
+	if (s.length <= max) return s;
+	return `${s.slice(0, max - 3)}...`;
+}
+
+export function runList(): void {
+	const skills = scanInstalledSkills();
+
+	if (skills.length === 0) {
+		console.log("\n  No skills installed in ~/.claude/skills/\n");
+		return;
+	}
+
+	const totalSize = skills.reduce((acc, s) => acc + s.size, 0);
+
+	console.log(`\n  ${bold(`INSTALLED SKILLS (${skills.length})`)}\n`);
+
+	const nameWidth = 24;
+	const descWidth = 42;
+	const sizeWidth = 10;
+
+	const header = `  ${"NAME".padEnd(nameWidth)}${"DESCRIPTION".padEnd(descWidth)}${"SIZE".padStart(sizeWidth)}`;
+	console.log(dim(header));
+
+	for (const skill of skills) {
+		const name = cyan(skill.name.padEnd(nameWidth));
+		const desc = dim(
+			truncate(skill.description || "", descWidth).padEnd(descWidth),
+		);
+		const size = formatSize(skill.size).padStart(sizeWidth);
+		console.log(`  ${name}${desc}${size}`);
+	}
+
+	console.log(
+		`\n  ${dim(`Total: ${skills.length} skills | ${formatSize(totalSize)} context budget`)}\n`,
+	);
+}

package/src/commands/stats.ts

@@ -0,0 +1,66 @@
+import { getDailyUsage, getSkillStats, getTopSkills } from "../db/queries";
+import { getDb } from "../db/schema";
+import { scanAllSessions } from "../scanner/index";
+import { bold, cyan, dim, yellow } from "../tui/colors";
+import { sparkline } from "../tui/sparkline";
+
+function getMostActiveDay(db: ReturnType<typeof getDb>): string {
+	const row = db
+		.query<{ day: string; count: number }, []>(
+			"SELECT strftime('%w', timestamp) as day, COUNT(*) as count FROM skill_invocations GROUP BY day ORDER BY count DESC LIMIT 1",
+		)
+		.get();
+	if (!row) return "N/A";
+	const days = [
+		"Sunday",
+		"Monday",
+		"Tuesday",
+		"Wednesday",
+		"Thursday",
+		"Friday",
+		"Saturday",
+	];
+	return days[parseInt(row.day, 10)] ?? "N/A";
+}
+
+export async function runStats(): Promise<void> {
+	const db = getDb();
+	console.log("\n  Scanning sessions...");
+	const newCount = await scanAllSessions(db);
+	if (newCount > 0) {
+		console.log(`  Found ${newCount} new invocations.\n`);
+	}
+
+	const stats = getSkillStats(db, 30);
+
+	if (stats.total === 0) {
+		console.log(`\n  ${yellow("No analytics data yet.")}`);
+		console.log(`  ${dim("Run: skill-kit analyze")}\n`);
+		return;
+	}
+
+	const topSkills = getTopSkills(db, 30);
+	const activeDay = getMostActiveDay(db);
+
+	console.log(`\n  ${bold("SKILL-KIT ANALYTICS")} ${dim("(last 30 days)")}\n`);
+	console.log(`  Total invocations: ${bold(String(stats.total))}`);
+	console.log(`  Unique skills:     ${bold(String(stats.unique_skills))}`);
+	console.log(`  Most active day:   ${bold(activeDay)}\n`);
+	console.log(`  ${bold("TOP SKILLS")}\n`);
+
+	const maxCount = topSkills.length > 0 ? (topSkills[0]?.total ?? 1) : 1;
+	const barWidth = 20;
+
+	for (const skill of topSkills.slice(0, 10)) {
+		const daily = getDailyUsage(db, skill.skill_name, 30);
+		const filled = Math.round((skill.total / maxCount) * barWidth);
+		const bar = "█".repeat(filled);
+		const spark = sparkline(daily.map((d) => d.count));
+		const name = cyan(skill.skill_name.padEnd(16));
+		console.log(
+			`  ${name}  ${bar.padEnd(barWidth)}  ${String(skill.total).padStart(4)}  ${spark}`,
+		);
+	}
+
+	console.log();
+}

package/src/db/queries.ts

@@ -0,0 +1,110 @@
+import type { Database } from "bun:sqlite";
+
+interface TopSkillRow {
+	skill_name: string;
+	total: number;
+}
+
+interface StatsRow {
+	total: number;
+	unique_skills: number;
+}
+
+interface DailyRow {
+	date: string;
+	count: number;
+}
+
+interface InstalledSkillRow {
+	name: string;
+	path: string;
+	installed_at: string;
+	source: string | null;
+	version: string | null;
+	size_bytes: number | null;
+}
+
+export function getTopSkills(db: Database, days = 30): TopSkillRow[] {
+	const cutoff = new Date(
+		Date.now() - days * 24 * 60 * 60 * 1000,
+	).toISOString();
+	return db
+		.query<TopSkillRow, [string]>(
+			"SELECT skill_name, COUNT(*) as total FROM skill_invocations WHERE timestamp >= ? GROUP BY skill_name ORDER BY total DESC LIMIT 20",
+		)
+		.all(cutoff);
+}
+
+export function getSkillStats(db: Database, days = 30): StatsRow {
+	const cutoff = new Date(
+		Date.now() - days * 24 * 60 * 60 * 1000,
+	).toISOString();
+	return (
+		db
+			.query<StatsRow, [string]>(
+				"SELECT COUNT(*) as total, COUNT(DISTINCT skill_name) as unique_skills FROM skill_invocations WHERE timestamp >= ?",
+			)
+			.get(cutoff) ?? { total: 0, unique_skills: 0 }
+	);
+}
+
+export function getDailyUsage(
+	db: Database,
+	skillName: string,
+	days = 30,
+): DailyRow[] {
+	const cutoff = new Date(
+		Date.now() - days * 24 * 60 * 60 * 1000,
+	).toISOString();
+	return db
+		.query<DailyRow, [string, string]>(
+			"SELECT date(timestamp) as date, COUNT(*) as count FROM skill_invocations WHERE skill_name = ? AND timestamp >= ? GROUP BY date(timestamp) ORDER BY date ASC",
+		)
+		.all(skillName, cutoff);
+}
+
+export function getInstalledSkills(db: Database): InstalledSkillRow[] {
+	return db
+		.query<InstalledSkillRow, []>(
+			"SELECT * FROM installed_skills ORDER BY name ASC",
+		)
+		.all();
+}
+
+export function recordInvocation(
+	db: Database,
+	skillName: string,
+	sessionId?: string,
+	project?: string,
+): void {
+	db.run(
+		"INSERT INTO skill_invocations (skill_name, timestamp, session_id, project) VALUES (?, ?, ?, ?)",
+		[skillName, new Date().toISOString(), sessionId ?? null, project ?? null],
+	);
+	const date = new Date().toISOString().slice(0, 10);
+	db.run(
+		"INSERT INTO skill_daily_stats (date, skill_name, count) VALUES (?, ?, 1) ON CONFLICT(date, skill_name) DO UPDATE SET count = count + 1",
+		[date, skillName],
+	);
+}
+
+export function upsertInstalledSkill(
+	db: Database,
+	name: string,
+	path: string,
+	source?: string,
+	version?: string,
+	sizeBytes?: number,
+): void {
+	db.run(
+		"INSERT INTO installed_skills (name, path, installed_at, source, version, size_bytes) VALUES (?, ?, ?, ?, ?, ?) ON CONFLICT(name) DO UPDATE SET path = excluded.path, source = excluded.source, version = excluded.version, size_bytes = excluded.size_bytes",
+		[
+			name,
+			path,
+			new Date().toISOString(),
+			source ?? null,
+			version ?? null,
+			sizeBytes ?? null,
+		],
+	);
+}

package/src/db/schema.ts

@@ -0,0 +1,51 @@
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const DB_DIR = join(homedir(), ".skill-kit");
+const DB_PATH = join(DB_DIR, "analytics.db");
+
+export function getDb(): Database {
+	mkdirSync(DB_DIR, { recursive: true });
+	const db = new Database(DB_PATH);
+	db.run("PRAGMA journal_mode=WAL");
+	db.run(`
+		CREATE TABLE IF NOT EXISTS skill_invocations (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			skill_name TEXT NOT NULL,
+			timestamp TEXT NOT NULL,
+			session_id TEXT,
+			project TEXT,
+			success INTEGER DEFAULT 1
+		)
+	`);
+	db.run(`
+		CREATE TABLE IF NOT EXISTS skill_daily_stats (
+			date TEXT NOT NULL,
+			skill_name TEXT NOT NULL,
+			count INTEGER DEFAULT 0,
+			UNIQUE(date, skill_name)
+		)
+	`);
+	db.run(`
+		CREATE TABLE IF NOT EXISTS installed_skills (
+			name TEXT PRIMARY KEY,
+			path TEXT NOT NULL,
+			installed_at TEXT NOT NULL,
+			source TEXT,
+			version TEXT,
+			size_bytes INTEGER
+		)
+	`);
+	db.run(
+		"CREATE INDEX IF NOT EXISTS idx_invocations_skill ON skill_invocations(skill_name)",
+	);
+	db.run(
+		"CREATE INDEX IF NOT EXISTS idx_invocations_ts ON skill_invocations(timestamp DESC)",
+	);
+	db.run(
+		"CREATE INDEX IF NOT EXISTS idx_daily_date ON skill_daily_stats(date DESC)",
+	);
+	return db;
+}

package/src/index.ts

@@ -0,0 +1,19 @@
+export { runHealth } from "./commands/health";
+export { runList } from "./commands/list";
+export { runStats } from "./commands/stats";
+export {
+	getDailyUsage,
+	getInstalledSkills,
+	getSkillStats,
+	getTopSkills,
+	recordInvocation,
+	upsertInstalledSkill,
+} from "./db/queries";
+export { getDb } from "./db/schema";
+export { parseSessionFile, scanAllSessions } from "./scanner/index";
+export { scanInstalledSkills } from "./scanner/skills";
+export type {
+	InstalledSkill,
+	SkillInvocation,
+	SkillStats,
+} from "./types/index";

package/src/scanner/index.ts

@@ -0,0 +1,129 @@
+import type { Database } from "bun:sqlite";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import { recordInvocation } from "../db/queries";
+
+interface ToolUseBlock {
+	type: "tool_use";
+	name: string;
+	input: Record<string, unknown>;
+}
+
+interface AssistantMessage {
+	type: "assistant";
+	message: {
+		content: Array<ToolUseBlock | { type: string }>;
+	};
+}
+
+function extractSessionId(filePath: string): string {
+	return basename(filePath, ".jsonl");
+}
+
+function extractSkillName(block: ToolUseBlock): string | null {
+	const input = block.input;
+	if (typeof input.skill === "string") return input.skill;
+	if (typeof input.name === "string") return input.name;
+	if (typeof input.skillName === "string") return input.skillName;
+	return null;
+}
+
+export function parseSessionFile(
+	filePath: string,
+): Array<{ skillName: string; timestamp: string; sessionId: string }> {
+	const results: Array<{
+		skillName: string;
+		timestamp: string;
+		sessionId: string;
+	}> = [];
+	const sessionId = extractSessionId(filePath);
+
+	let content: string;
+	try {
+		content = readFileSync(filePath, "utf-8");
+	} catch {
+		return results;
+	}
+
+	const lines = content.split("\n");
+	for (const line of lines) {
+		if (!line.trim()) continue;
+		let entry: unknown;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+
+		if (typeof entry !== "object" || entry === null) continue;
+		const obj = entry as Record<string, unknown>;
+
+		const timestamp =
+			typeof obj.timestamp === "string"
+				? obj.timestamp
+				: new Date().toISOString();
+
+		const msg = obj.message as AssistantMessage["message"] | undefined;
+		const content = obj.type === "assistant" && msg ? msg.content : null;
+
+		if (!Array.isArray(content)) continue;
+
+		for (const block of content) {
+			if (
+				typeof block === "object" &&
+				block !== null &&
+				(block as Record<string, unknown>).type === "tool_use" &&
+				(block as ToolUseBlock).name === "Skill"
+			) {
+				const skillName = extractSkillName(block as ToolUseBlock);
+				if (skillName) {
+					results.push({ skillName, timestamp, sessionId });
+				}
+			}
+		}
+	}
+
+	return results;
+}
+
+interface AlreadyTracked {
+	session_id: string;
+	timestamp: string;
+}
+
+export async function scanAllSessions(db: Database): Promise<number> {
+	const projectsDir = join(homedir(), ".claude", "projects");
+	if (!existsSync(projectsDir)) return 0;
+
+	const glob = new Bun.Glob("**/*.jsonl");
+	const files: string[] = [];
+
+	for await (const file of glob.scan({ cwd: projectsDir, absolute: true })) {
+		files.push(file);
+	}
+
+	const tracked = db
+		.query<AlreadyTracked, []>(
+			"SELECT session_id, timestamp FROM skill_invocations WHERE session_id IS NOT NULL",
+		)
+		.all();
+	const trackedSet = new Set(
+		tracked.map((r) => `${r.session_id}::${r.timestamp}`),
+	);
+
+	let newCount = 0;
+	for (const file of files) {
+		const invocations = parseSessionFile(file);
+		for (const inv of invocations) {
+			const key = `${inv.sessionId}::${inv.timestamp}`;
+			if (!trackedSet.has(key)) {
+				recordInvocation(db, inv.skillName, inv.sessionId);
+				trackedSet.add(key);
+				newCount++;
+			}
+		}
+	}
+
+	return newCount;
+}

package/src/scanner/skills.ts

@@ -0,0 +1,102 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { InstalledSkill } from "../types";
+
+function parseYamlFrontmatter(content: string): Record<string, string> {
+	const match = content.match(/^---\n([\s\S]*?)\n---/);
+	if (!match || !match[1]) return {};
+	const result: Record<string, string> = {};
+	for (const line of match[1].split("\n")) {
+		const colonIdx = line.indexOf(":");
+		if (colonIdx === -1) continue;
+		const key = line.slice(0, colonIdx).trim();
+		const value = line
+			.slice(colonIdx + 1)
+			.trim()
+			.replace(/^["']|["']$/g, "");
+		if (key) result[key] = value;
+	}
+	return result;
+}
+
+function getDirSize(dirPath: string): number {
+	let total = 0;
+	try {
+		const entries = readdirSync(dirPath, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = join(dirPath, entry.name);
+			if (entry.isDirectory()) {
+				total += getDirSize(fullPath);
+			} else {
+				try {
+					total += statSync(fullPath).size;
+				} catch {}
+			}
+		}
+	} catch {}
+	return total;
+}
+
+export function scanInstalledSkills(): InstalledSkill[] {
+	const skillsDir = join(homedir(), ".claude", "skills");
+	if (!existsSync(skillsDir)) return [];
+
+	const skills: InstalledSkill[] = [];
+
+	let entries: string[];
+	try {
+		entries = readdirSync(skillsDir);
+	} catch {
+		return skills;
+	}
+
+	for (const entry of entries) {
+		const skillPath = join(skillsDir, entry);
+		let stat: ReturnType<typeof statSync>;
+		try {
+			stat = statSync(skillPath);
+		} catch {
+			continue;
+		}
+		if (!stat.isDirectory()) continue;
+
+		const skillMdPath = join(skillPath, "SKILL.md");
+		let description = "";
+		let name = entry;
+
+		if (existsSync(skillMdPath)) {
+			try {
+				const content = readFileSync(skillMdPath, "utf-8");
+				const frontmatter = parseYamlFrontmatter(content);
+				if (frontmatter.name) name = frontmatter.name;
+				if (frontmatter.description) description = frontmatter.description;
+				if (!description) {
+					const lines = content
+						.replace(/^---[\s\S]*?---\n/, "")
+						.trim()
+						.split("\n");
+					for (const line of lines) {
+						const cleaned = line.replace(/^#+\s*/, "").trim();
+						if (cleaned && !cleaned.startsWith("---")) {
+							description = cleaned;
+							break;
+						}
+					}
+				}
+			} catch {}
+		}
+
+		const size = getDirSize(skillPath);
+
+		skills.push({
+			name,
+			path: skillPath,
+			description,
+			size,
+			installedAt: new Date(stat.birthtime).toISOString(),
+		});
+	}
+
+	return skills.sort((a, b) => a.name.localeCompare(b.name));
+}

package/src/tui/bar.ts

@@ -0,0 +1,20 @@
+import { dim, green } from "./colors";
+
+export function barChart(
+	items: { name: string; value: number }[],
+	width = 20,
+): string {
+	if (items.length === 0) return "";
+	const max = Math.max(...items.map((i) => i.value));
+	const maxNameLen = Math.max(...items.map((i) => i.name.length));
+
+	return items
+		.map((item) => {
+			const filled = max === 0 ? 0 : Math.round((item.value / max) * width);
+			const empty = width - filled;
+			const bar = green("█".repeat(filled)) + dim("░".repeat(empty));
+			const name = item.name.padStart(maxNameLen);
+			return `  ${name}  ${bar}  ${item.value}`;
+		})
+		.join("\n");
+}

package/src/tui/colors.ts

@@ -0,0 +1,14 @@
+const isTTY = process.stdout.isTTY ?? false;
+
+function ansi(code: string, s: string): string {
+	if (!isTTY) return s;
+	return `${code}${s}\x1b[0m`;
+}
+
+export const green = (s: string) => ansi("\x1b[32m", s);
+export const red = (s: string) => ansi("\x1b[31m", s);
+export const yellow = (s: string) => ansi("\x1b[33m", s);
+export const dim = (s: string) => ansi("\x1b[2m", s);
+export const bold = (s: string) => ansi("\x1b[1m", s);
+export const cyan = (s: string) => ansi("\x1b[36m", s);
+export const emerald = (s: string) => ansi("\x1b[38;5;48m", s);

package/src/tui/health.ts

@@ -0,0 +1,12 @@
+import { green, red, yellow } from "./colors";
+
+export function healthGauge(score: number): string {
+	const clamped = Math.max(0, Math.min(100, Math.round(score)));
+	const filled = Math.round(clamped / 10);
+	const empty = 10 - filled;
+	const bar = "█".repeat(filled) + "░".repeat(empty);
+	const pct = `${clamped}%`;
+	const colored =
+		clamped >= 80 ? green(bar) : clamped >= 60 ? yellow(bar) : red(bar);
+	return `[${colored}] ${pct}`;
+}

package/src/tui/sparkline.ts

@@ -0,0 +1,17 @@
+import { green } from "./colors";
+
+const SPARKS = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+
+export function sparkline(values: number[]): string {
+	if (values.length === 0) return "";
+	const max = Math.max(...values);
+	if (max === 0) {
+		const line = (SPARKS[0] ?? "▁").repeat(values.length);
+		return green(line);
+	}
+	const chars = values.map((v) => {
+		const idx = Math.min(Math.floor((v / max) * 7), 7);
+		return SPARKS[idx] ?? "█";
+	});
+	return green(chars.join(""));
+}

package/src/types/index.ts

@@ -0,0 +1,20 @@
+export interface InstalledSkill {
+	name: string;
+	path: string;
+	description: string;
+	size: number;
+	installedAt: string;
+}
+
+export interface SkillInvocation {
+	skillName: string;
+	timestamp: string;
+	sessionId: string;
+	project: string;
+}
+
+export interface SkillStats {
+	name: string;
+	count: number;
+	dailyCounts: number[];
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": {
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"types": ["bun-types"]
+	},
+	"include": ["src"]
+}