@crafter/skillkit 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@crafter/skillkit",
-	"version": "0.1.5",
+	"version": "0.1.7",
 	"description": "Local-first analytics for AI agent skills. Track usage, measure context budget, and prune what you don't use.",
 	"type": "module",
 	"bin": {

package/src/bin.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { bold, cyan, dim, yellow } from "./tui/colors";
 
-const VERSION = "0.1.5";
+const VERSION = "0.1.7";
 
 function printHelp(): void {
 	console.log(`

package/src/commands/scan.ts

@@ -1,9 +1,8 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 import { upsertInstalledSkill } from "../db/queries";
 import { getDb } from "../db/schema";
-import { scanAllSessions } from "../scanner/index";
+import { scanAllSessions, countAllSessions } from "../scanner/index";
 import { getDetectedAgents, scanInstalledSkills } from "../scanner/skills";
 import { bold, cyan, dim } from "../tui/colors";
 
@@ -22,18 +21,6 @@ function detectSource(skillPath: string): "skills.sh" | "manual" {
 	return "manual";
 }
 
-function countSessions(): number {
-	const projectsDir = join(homedir(), ".claude", "projects");
-	if (!existsSync(projectsDir)) return 0;
-
-	let count = 0;
-	const glob = new Bun.Glob("**/*.jsonl");
-	for (const _ of glob.scanSync({ cwd: projectsDir })) {
-		count++;
-	}
-	return count;
-}
-
 export async function runScan(): Promise<void> {
 	const db = getDb();
 
@@ -99,7 +86,7 @@ export async function runScan(): Promise<void> {
 
 	console.log(dim("  Scanning sessions..."));
 
-	const sessionCount = countSessions();
+	const sessionCount = countAllSessions();
 	const newInvocations = await scanAllSessions(db);
 	const totalRow = db
 		.query<{ count: number }, []>(

package/src/index.ts

@@ -12,7 +12,8 @@ export {
 	upsertInstalledSkill,
 } from "./db/queries";
 export { getDb } from "./db/schema";
-export { parseSessionFile, scanAllSessions } from "./scanner/index";
+export { scanAllSessions, countAllSessions } from "./scanner/index";
+export { parseSessionFile } from "./scanner/connectors/claude";
 export { getDetectedAgents, scanInstalledSkills } from "./scanner/skills";
 export type {
 	InstalledSkill,

package/src/scanner/connectors/claude.ts

@@ -0,0 +1,112 @@
+import type { Database } from "bun:sqlite";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import type { Invocation } from "../index";
+import { recordNewInvocations } from "../index";
+
+interface ToolUseBlock {
+	type: "tool_use";
+	name: string;
+	input: Record<string, unknown>;
+}
+
+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): Invocation[] {
+	const results: Invocation[] = [];
+	const sessionId = basename(filePath, ".jsonl");
+
+	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
+			| { content: Array<Record<string, unknown>> }
+			| undefined;
+		const msgContent =
+			obj.type === "assistant" && msg ? msg.content : null;
+
+		if (!Array.isArray(msgContent)) continue;
+
+		for (const block of msgContent) {
+			if (
+				typeof block === "object" &&
+				block !== null &&
+				block.type === "tool_use" &&
+				(block as unknown as ToolUseBlock).name === "Skill"
+			) {
+				const skillName = extractSkillName(
+					block as unknown as ToolUseBlock,
+				);
+				if (skillName) {
+					results.push({ skillName, timestamp, sessionId });
+				}
+			}
+		}
+	}
+
+	return results;
+}
+
+export function countClaudeSessions(): number {
+	const projectsDir = join(homedir(), ".claude", "projects");
+	if (!existsSync(projectsDir)) return 0;
+
+	let count = 0;
+	const glob = new Bun.Glob("**/*.jsonl");
+	for (const _ of glob.scanSync({ cwd: projectsDir })) {
+		count++;
+	}
+	return count;
+}
+
+export async function scanClaudeSessions(
+	db: Database,
+	trackedSet: Set<string>,
+): 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);
+	}
+
+	let total = 0;
+	for (const file of files) {
+		const invocations = parseSessionFile(file);
+		total += recordNewInvocations(db, trackedSet, invocations);
+	}
+
+	return total;
+}

package/src/scanner/connectors/opencode.ts

@@ -0,0 +1,116 @@
+import { Database as BunDatabase } from "bun:sqlite";
+import type { Database } from "bun:sqlite";
+import { existsSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+import { recordNewInvocations } from "../index";
+import type { Invocation } from "../index";
+
+function getDbPath(): string | null {
+	const os = platform();
+	let dataDir: string;
+	if (os === "darwin") {
+		dataDir = join(homedir(), "Library", "Application Support", "opencode");
+	} else if (os === "win32") {
+		dataDir = join(
+			process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local"),
+			"opencode",
+		);
+	} else {
+		dataDir = join(
+			process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"),
+			"opencode",
+		);
+	}
+	const dbPath = join(dataDir, "opencode.db");
+	return existsSync(dbPath) ? dbPath : null;
+}
+
+function openDb(): InstanceType<typeof BunDatabase> | null {
+	const dbPath = getDbPath();
+	if (!dbPath) return null;
+	try {
+		return new BunDatabase(dbPath, { readonly: true });
+	} catch {
+		return null;
+	}
+}
+
+interface PartRow {
+	session_id: string;
+	time_created: number;
+	data: string;
+}
+
+export function countOpenCodeSessions(): number {
+	const ocDb = openDb();
+	if (!ocDb) return 0;
+
+	try {
+		const row = ocDb
+			.query<{ count: number }, []>(
+				"SELECT COUNT(*) as count FROM session",
+			)
+			.get();
+		return row?.count ?? 0;
+	} catch {
+		return 0;
+	} finally {
+		ocDb.close();
+	}
+}
+
+export function scanOpenCodeSessions(
+	db: Database,
+	trackedSet: Set<string>,
+): number {
+	const ocDb = openDb();
+	if (!ocDb) return 0;
+
+	try {
+		const rows = ocDb
+			.query<PartRow, []>(
+				"SELECT p.session_id, p.time_created, p.data FROM part p WHERE p.data LIKE '%\"tool\":\"skill\"%'",
+			)
+			.all();
+
+		const invocations: Invocation[] = [];
+
+		for (const row of rows) {
+			let data: Record<string, unknown>;
+			try {
+				data = JSON.parse(row.data);
+			} catch {
+				continue;
+			}
+
+			if (data.type !== "tool" || data.tool !== "skill") continue;
+
+			const state = data.state as Record<string, unknown> | undefined;
+			if (!state) continue;
+
+			const input = state.input as Record<string, unknown> | undefined;
+			if (!input) continue;
+
+			const skillName =
+				typeof input.name === "string"
+					? input.name
+					: typeof input.skill === "string"
+						? input.skill
+						: null;
+			if (!skillName) continue;
+
+			invocations.push({
+				skillName,
+				timestamp: new Date(row.time_created).toISOString(),
+				sessionId: `oc:${row.session_id}`,
+			});
+		}
+
+		return recordNewInvocations(db, trackedSet, invocations);
+	} catch {
+		return 0;
+	} finally {
+		ocDb.close();
+	}
+}

package/src/scanner/index.ts

@@ -1,129 +1,56 @@
 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;
-}
+import { scanClaudeSessions, countClaudeSessions } from "./connectors/claude";
+import {
+	scanOpenCodeSessions,
+	countOpenCodeSessions,
+} from "./connectors/opencode";
 
 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);
-	}
-
+export function getTrackedSet(db: Database): Set<string> {
 	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}`),
-	);
+	return new Set(tracked.map((r) => `${r.session_id}::${r.timestamp}`));
+}
+
+export interface Invocation {
+	skillName: string;
+	timestamp: string;
+	sessionId: string;
+}
 
-	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++;
-			}
+export function recordNewInvocations(
+	db: Database,
+	trackedSet: Set<string>,
+	invocations: Invocation[],
+): number {
+	let count = 0;
+	for (const inv of invocations) {
+		const key = `${inv.sessionId}::${inv.timestamp}`;
+		if (!trackedSet.has(key)) {
+			recordInvocation(db, inv.skillName, inv.sessionId);
+			trackedSet.add(key);
+			count++;
 		}
 	}
+	return count;
+}
+
+export async function scanAllSessions(db: Database): Promise<number> {
+	const trackedSet = getTrackedSet(db);
+	let total = 0;
+	total += await scanClaudeSessions(db, trackedSet);
+	total += scanOpenCodeSessions(db, trackedSet);
+	return total;
+}
 
-	return newCount;
+export function countAllSessions(): number {
+	return countClaudeSessions() + countOpenCodeSessions();
 }