@stzhu/skills 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Steve Zhu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# @stzhu/skills
+
+A collection of CLI tools (skills) for AI agents and developers.
+
+## Installation
+
+```bash
+pnpm add @stzhu/skills
+```
+
+## Usage
+
+The CLI is available as `stz-skills`. You can also run it via `pnpx`:
+
+```bash
+pnpx @stzhu/skills <command>
+```
+
+### Agent Logbook
+
+Manage and validate AI agent activity logs in the `.agent-logbook/` directory.
+
+#### Get Session Stats
+
+Retrieve token usage and model information for a specific agent session.
+
+```bash
+# For Claude Code
+pnpx @stzhu/skills agent-logbook stats <session-id> --agent claudecode
+
+# For Gemini CLI
+pnpx @stzhu/skills agent-logbook stats <session-id> --agent geminicli
+```
+
+#### Validate Logbook Files
+
+Validate the filenames and frontmatter of your logbook entries.
+
+```bash
+# Validate all files in .agent-logbook/
+pnpx @stzhu/skills agent-logbook validate
+
+# Validate a specific file or directory
+pnpx @stzhu/skills agent-logbook validate .agent-logbook/activity/
+```
+
+## License
+
+MIT

package/dist/bash-complete.mjs

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { n as app, t as buildContext } from "./context-SQBI_fVn.mjs";
+import { proposeCompletions } from "@stricli/core";
+
+//#region src/bin/bash-complete.ts
+const inputs = process.argv.slice(3);
+if (process.env["COMP_LINE"]?.endsWith(" ")) inputs.push("");
+await proposeCompletions(app, inputs, buildContext(process));
+try {
+	for (const { completion } of await proposeCompletions(app, inputs, buildContext(process))) process.stdout.write(`${completion}\n`);
+} catch {}
+
+//#endregion
+export {  };

package/dist/cli.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { n as app, t as buildContext } from "./context-SQBI_fVn.mjs";
+import { run } from "@stricli/core";
+
+//#region src/bin/cli.ts
+await run(app, process.argv.slice(2), buildContext(process));
+
+//#endregion
+export {  };

package/dist/context-SQBI_fVn.mjs

@@ -0,0 +1,102 @@
+import { buildApplication, buildCommand, buildRouteMap } from "@stricli/core";
+import { buildInstallCommand, buildUninstallCommand } from "@stricli/auto-complete";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { findWorkspacesRoot } from "find-workspaces";
+
+//#region package.json
+var version = "0.1.0";
+var description = "Skills CLI";
+var bin = {
+	"__stz-skills_bash_complete": "dist/bash-complete.mjs",
+	"stz-skills": "dist/cli.mjs"
+};
+
+//#endregion
+//#region src/commands/agent-logbook/commands.ts
+const statsCommand = buildCommand({
+	loader: async () => {
+		const { stats } = await import("./stats-RlcmzM9e.mjs");
+		return stats;
+	},
+	parameters: {
+		flags: { agent: {
+			kind: "enum",
+			brief: "The agent to get stats for",
+			values: ["claudecode", "geminicli"]
+		} },
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				parse: String,
+				brief: "The session ID to get stats for"
+			}]
+		}
+	},
+	docs: { brief: "Agent logbook stats command" }
+});
+const validateCommand = buildCommand({
+	loader: async () => {
+		const { validate } = await import("./validate-D3AdsB3Q.mjs");
+		return validate;
+	},
+	parameters: { positional: {
+		kind: "tuple",
+		parameters: [{
+			parse: String,
+			brief: "The target file or directory to validate frontmatter for",
+			optional: true
+		}]
+	} },
+	docs: { brief: "Agent logbook validate command" }
+});
+const agentLogbookRoutes = buildRouteMap({
+	routes: {
+		stats: statsCommand,
+		validate: validateCommand
+	},
+	docs: { brief: "Agent logbook commands" }
+});
+
+//#endregion
+//#region src/app.ts
+const routes = buildRouteMap({
+	routes: {
+		"agent-logbook": agentLogbookRoutes,
+		install: buildInstallCommand("stz-skills", { bash: "__stz-skills_bash_complete" }),
+		uninstall: buildUninstallCommand("stz-skills", { bash: true })
+	},
+	docs: {
+		brief: description,
+		hideRoute: {
+			install: true,
+			uninstall: true
+		}
+	}
+});
+const app = buildApplication(routes, {
+	name: (() => {
+		const name = Object.keys(bin).find((key) => !key.startsWith("__"));
+		if (!name) throw new Error("Name not found");
+		return name;
+	})(),
+	versionInfo: { currentVersion: version }
+});
+
+//#endregion
+//#region src/context.ts
+function buildContext(process) {
+	const workspacesRoot = findWorkspacesRoot();
+	if (!workspacesRoot) throw new Error("Not in an npm project");
+	return {
+		process,
+		os,
+		fs,
+		path,
+		workspacesRoot: workspacesRoot.location
+	};
+}
+
+//#endregion
+export { app as n, buildContext as t };

package/dist/stats-RlcmzM9e.mjs

@@ -0,0 +1,341 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+
+//#region src/util/defineCommandFunction.ts
+/**
+* Identity wrapper for strongly typed command implementations.
+*
+* Keeps generic flag/arg/context types attached to the command function so
+* call sites get full inference and editor hints.
+*/
+function defineCommandFunction(impl) {
+	return impl;
+}
+
+//#endregion
+//#region src/commands/agent-logbook/stats/formatSessionStatsOutput.ts
+/**
+* Formats a StatsResult into a human-readable table/report for the CLI.
+*
+* @param agentName Name of the agent (e.g., ClaudeCode).
+* @param sessionId Unique ID of the session.
+* @param result Aggregated data to display.
+*/
+function formatSessionStatsOutput(agentName, sessionId, result) {
+	const lines = [];
+	lines.push("");
+	lines.push(`${agentName} Session Stats: ${sessionId}`);
+	lines.push("========================================");
+	if (result.models.length > 0) {
+		const modelsMeta = result.meta?.filter(([label]) => label === "Models" || label === "");
+		if (modelsMeta && modelsMeta.length > 0) {
+			for (const [label, value] of modelsMeta) if (label === "Models") lines.push(`Models Used:  ${value}`);
+			else if (label === "") lines.push(`              ${value}`);
+		} else lines.push(`Models Used:  ${result.models.join(", ") || "N/A"}`);
+	}
+	if (result.meta) {
+		for (const [label, value] of result.meta) if (label !== "Models" && label !== "") lines.push(`${label}:  ${value}`);
+	}
+	for (const section of result.sections) {
+		lines.push("----------------------------------------");
+		lines.push(`${section.label}:`);
+		for (const [label, value] of section.entries) {
+			const num = typeof value === "number" ? value.toLocaleString() : String(value);
+			lines.push(`  ${label.padEnd(20)} ${num}`);
+		}
+	}
+	if (result.summary) {
+		lines.push("----------------------------------------");
+		lines.push(`${result.summary.label}:`);
+		for (const [label, value] of result.summary.entries) {
+			const num = typeof value === "number" ? value.toLocaleString() : String(value);
+			lines.push(`  ${label.padEnd(20)} ${num}`);
+		}
+	}
+	lines.push("----------------------------------------");
+	lines.push(`GRAND TOTAL TOKENS:  ${typeof result.grandTotal === "number" ? result.grandTotal.toLocaleString() : result.grandTotal}`);
+	lines.push("========================================");
+	lines.push("");
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/commands/agent-logbook/stats/defineSessionStatsPlugin.ts
+/**
+* Identity wrapper for strongly typed session stats plugin implementations.
+*
+* Keeps types attached to the plugin object so call sites get full inference
+* and editor hints.
+*/
+function defineSessionStatsPlugin(plugin) {
+	return plugin;
+}
+
+//#endregion
+//#region src/commands/agent-logbook/stats/plugins/claudecode.ts
+/** Base directory where Claude Code stores project and session metadata. */
+const CLAUDECODE_PROJECTS_DIR = path.join(os.homedir(), ".claude", "projects");
+/**
+* Parses a single JSONL file from Claude's logs to extract token usage.
+* Only 'assistant' message types with 'usage' fields are counted.
+*
+* @param filePath Path to the .jsonl file.
+*/
+async function parseJsonlFile(filePath) {
+	const stats = {
+		input_tokens: 0,
+		output_tokens: 0,
+		cache_creation_input_tokens: 0,
+		cache_read_input_tokens: 0,
+		models: /* @__PURE__ */ new Set()
+	};
+	const fileStream = fs.createReadStream(filePath);
+	const rl = readline.createInterface({
+		input: fileStream,
+		crlfDelay: Infinity
+	});
+	for await (const line of rl) try {
+		const data = JSON.parse(line);
+		if (data.type === "assistant" && data.message && data.message.usage) {
+			const usage = data.message.usage;
+			stats.input_tokens += usage.input_tokens || 0;
+			stats.output_tokens += usage.output_tokens || 0;
+			stats.cache_creation_input_tokens += usage.cache_creation_input_tokens || 0;
+			stats.cache_read_input_tokens += usage.cache_read_input_tokens || 0;
+			if (data.message.model) stats.models.add(data.message.model);
+		}
+	} catch {}
+	return stats;
+}
+/**
+* Merges source stats into a target stats object.
+* Used for summing main session and subagent totals.
+*/
+function combineStats(target, source) {
+	target.input_tokens += source.input_tokens;
+	target.output_tokens += source.output_tokens;
+	target.cache_creation_input_tokens += source.cache_creation_input_tokens;
+	target.cache_read_input_tokens += source.cache_read_input_tokens;
+	source.models.forEach((m) => target.models.add(m));
+}
+/**
+* The ClaudeCode-specific stats plugin.
+* Handles parsing ClaudeCode's .jsonl logs found in ~/.claude/projects.
+*/
+const claudecodePlugin = defineSessionStatsPlugin({
+	name: "claudecode",
+	async findSession(sessionId) {
+		try {
+			const sessionLookup = (await fs.promises.readdir(CLAUDECODE_PROJECTS_DIR)).map(async (projectDir) => {
+				const projectPath = path.join(CLAUDECODE_PROJECTS_DIR, projectDir);
+				if (!(await fs.promises.stat(projectPath)).isDirectory()) throw new Error(`Not a directory: ${projectPath}`);
+				const sessionFile = path.join(projectPath, `${sessionId}.jsonl`);
+				const subagentsDir = path.join(projectPath, sessionId, "subagents");
+				await fs.promises.access(sessionFile);
+				let subagentFiles = [];
+				try {
+					subagentFiles = (await fs.promises.readdir(subagentsDir)).filter((f) => f.endsWith(".jsonl")).map((f) => path.join(subagentsDir, f));
+				} catch {}
+				return {
+					sessionFile,
+					subagentFiles
+				};
+			});
+			try {
+				return await Promise.any(sessionLookup);
+			} catch (error) {
+				if (error instanceof AggregateError) return null;
+				throw error;
+			}
+		} catch (error) {
+			console.error("Error searching projects directory:", error.message);
+		}
+		return null;
+	},
+	async aggregateStats(sessionData) {
+		const mainStats = await parseJsonlFile(sessionData.sessionFile);
+		const totalStats = {
+			...mainStats,
+			models: new Set(mainStats.models)
+		};
+		const subagentsStats = {
+			input_tokens: 0,
+			output_tokens: 0,
+			cache_creation_input_tokens: 0,
+			cache_read_input_tokens: 0,
+			models: /* @__PURE__ */ new Set(),
+			count: sessionData.subagentFiles.length
+		};
+		const allSubagentStats = await Promise.all(sessionData.subagentFiles.map((file) => parseJsonlFile(file)));
+		for (const stats of allSubagentStats) {
+			combineStats(subagentsStats, stats);
+			combineStats(totalStats, stats);
+		}
+		const models = Array.from(totalStats.models);
+		const meta = [];
+		const sections = [{
+			label: "MAIN SESSION",
+			entries: [
+				["Input Tokens", mainStats.input_tokens],
+				["Output Tokens", mainStats.output_tokens],
+				["Cache Creation Input", mainStats.cache_creation_input_tokens],
+				["Cache Read Input", mainStats.cache_read_input_tokens]
+			]
+		}];
+		if (subagentsStats.count > 0) {
+			const modelLine = `Main: ${Array.from(mainStats.models).join(", ") || "N/A"}`;
+			const subLine = `Subagents: ${Array.from(subagentsStats.models).join(", ") || "N/A"}`;
+			meta.push(["Models", modelLine]);
+			meta.push(["", subLine]);
+			sections.push({
+				label: `SUBAGENTS (${subagentsStats.count} total)`,
+				entries: [
+					["Input Tokens", subagentsStats.input_tokens],
+					["Output Tokens", subagentsStats.output_tokens],
+					["Cache Creation Input", subagentsStats.cache_creation_input_tokens],
+					["Cache Read Input", subagentsStats.cache_read_input_tokens]
+				]
+			});
+		}
+		return {
+			models,
+			meta,
+			sections,
+			summary: {
+				label: "TOTAL USAGE",
+				entries: [
+					["Total Input Tokens", totalStats.input_tokens],
+					["Total Output Tokens", totalStats.output_tokens],
+					["Total Cache Creation", totalStats.cache_creation_input_tokens],
+					["Total Cache Read", totalStats.cache_read_input_tokens]
+				]
+			},
+			grandTotal: totalStats.input_tokens + totalStats.output_tokens + totalStats.cache_creation_input_tokens + totalStats.cache_read_input_tokens
+		};
+	}
+});
+
+//#endregion
+//#region src/commands/agent-logbook/stats/plugins/geminicli.ts
+/** Base directory where Gemini CLI stores its temporary session data. */
+const GEMINICLI_TMP_DIR = path.join(os.homedir(), ".gemini", "tmp");
+/**
+* Helper to read and parse a JSON file from the filesystem.
+* @param filePath Path to the .json file.
+*/
+async function readJsonFile(filePath) {
+	const content = await fs.promises.readFile(filePath, "utf8");
+	return JSON.parse(content);
+}
+/**
+* The GeminiCLI-specific stats plugin.
+* Handles parsing GeminiCLI session JSON files found in ~/.gemini/tmp.
+*/
+const geminicliPlugin = defineSessionStatsPlugin({
+	name: "geminicli",
+	async findSession(sessionId) {
+		const matchingFiles = [];
+		try {
+			const projectDirs = await fs.promises.readdir(GEMINICLI_TMP_DIR);
+			const dirResults = await Promise.all(projectDirs.map(async (projectDir) => {
+				const chatsDir = path.join(GEMINICLI_TMP_DIR, projectDir, "chats");
+				try {
+					const jsonFiles = (await fs.promises.readdir(chatsDir)).filter((f) => f.endsWith(".json")).map((f) => path.join(chatsDir, f));
+					return (await Promise.all(jsonFiles.map(async (filePath) => {
+						return (await readJsonFile(filePath)).sessionId === sessionId ? filePath : null;
+					}))).filter((f) => f !== null);
+				} catch {
+					return [];
+				}
+			}));
+			matchingFiles.push(...dirResults.flat());
+		} catch (error) {
+			console.error("Error searching gemini tmp directory:", error.message);
+		}
+		return matchingFiles.length > 0 ? matchingFiles : null;
+	},
+	async aggregateStats(sessionFiles) {
+		const stats = {
+			input: 0,
+			output: 0,
+			cached: 0,
+			thoughts: 0,
+			tool: 0,
+			total: 0,
+			models: /* @__PURE__ */ new Set()
+		};
+		const results = await Promise.all(sessionFiles.map(async (filePath) => {
+			try {
+				return await readJsonFile(filePath);
+			} catch (error) {
+				console.error(`Error processing file ${filePath}:`, error.message);
+				return null;
+			}
+		}));
+		for (const data of results) {
+			if (!data?.messages || !Array.isArray(data.messages)) continue;
+			for (const msg of data.messages) if (msg.type === "gemini" && msg.tokens) {
+				stats.input += msg.tokens.input || 0;
+				stats.output += msg.tokens.output || 0;
+				stats.cached += msg.tokens.cached || 0;
+				stats.thoughts += msg.tokens.thoughts || 0;
+				stats.tool += msg.tokens.tool || 0;
+				stats.total += msg.tokens.total || 0;
+				if (msg.model) stats.models.add(msg.model);
+			}
+		}
+		return {
+			models: Array.from(stats.models),
+			meta: [["Files Found", sessionFiles.length]],
+			sections: [{
+				label: "TOKEN USAGE",
+				entries: [
+					["Input Tokens", stats.input - stats.cached],
+					["Output Tokens", stats.output],
+					["Cached Tokens", stats.cached],
+					["Thoughts Tokens", stats.thoughts],
+					["Tool Tokens", stats.tool]
+				]
+			}],
+			summary: null,
+			grandTotal: stats.total
+		};
+	}
+});
+
+//#endregion
+//#region src/commands/agent-logbook/stats/index.ts
+/** Mapping of agent names to their respective stats plugins. */
+const plugins = {
+	claudecode: claudecodePlugin,
+	geminicli: geminicliPlugin
+};
+/**
+* The 'stats' command implementation.
+* Retrieves and displays aggregated token usage for a given agent session.
+*/
+const stats = defineCommandFunction(async function stats({ agent }, sessionId) {
+	if (!agent || !sessionId) {
+		console.error("Usage: session-stats.js <agent> <session-id>");
+		console.error("Agents: claudecode, geminicli");
+		process.exit(1);
+	}
+	const plugin = plugins[agent];
+	if (!plugin) {
+		console.error(`Unknown agent: ${agent}`);
+		console.error("Available agents: claudecode, geminicli");
+		process.exit(1);
+	}
+	const sessionData = await plugin.findSession(sessionId);
+	if (!sessionData) {
+		console.error(`Session not found for ID: ${sessionId}`);
+		process.exit(1);
+	}
+	const result = await plugin.aggregateStats(sessionData);
+	console.log(formatSessionStatsOutput(plugin.name, sessionId, result));
+});
+
+//#endregion
+export { stats };

package/dist/validate-D3AdsB3Q.mjs

@@ -0,0 +1,104 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import matter from "gray-matter";
+import { Compile } from "typebox/compile";
+import yaml from "yaml";
+import { Type } from "typebox";
+
+//#region src/commands/agent-logbook/validate/frontmatterSchema.ts
+const IsoDate = Type.Codec(Type.String({ format: "date-time" })).Decode((value) => new Date(value)).Encode((value) => value.toISOString());
+/**
+* TypeBox schema for agent logbook frontmatter.
+*/
+const FrontmatterSchema = Type.Object({
+	date: IsoDate,
+	type: Type.Union([
+		Type.Literal("activity"),
+		Type.Literal("research"),
+		Type.Literal("decision"),
+		Type.Literal("plan")
+	]),
+	status: Type.Union([
+		Type.Literal("complete"),
+		Type.Literal("in-progress"),
+		Type.Literal("abandoned"),
+		Type.Literal("success"),
+		Type.Literal("failure"),
+		Type.Literal("partial")
+	]),
+	agent: Type.String({ minLength: 1 }),
+	branch: Type.String({ minLength: 1 }),
+	models: Type.Array(Type.String(), { minItems: 1 }),
+	sessionId: Type.Optional(Type.String()),
+	taskId: Type.Optional(Type.String()),
+	cost: Type.Optional(Type.String()),
+	tags: Type.Optional(Type.Array(Type.String())),
+	filesModified: Type.Optional(Type.Array(Type.String())),
+	relatedPlan: Type.Optional(Type.String()),
+	migrated: Type.Optional(Type.Boolean())
+}, { additionalProperties: false });
+
+//#endregion
+//#region src/commands/agent-logbook/validate/index.ts
+/**
+* Expected filename format: `YYYY-MM-DD_HHMMSSZ_<agent>_<task-slug>.md`
+*
+* - `[0-9]{4}-[0-9]{2}-[0-9]{2}` — date (YYYY-MM-DD)
+* - `[0-9]{6}Z`                  — UTC time without separators (HHMMSS) + Z suffix
+* - `[a-z][a-z0-9-]*`            — agent name: starts with a letter, then letters/digits/hyphens
+* - `[a-z][a-z0-9-]+`            — task slug: same rules, but at least 2 characters
+*
+* Example: `2024-03-15_143022Z_claudecode_my-task.md`
+*/
+const FILENAME_RE = /^[0-9]{4}-[0-9]{2}-[0-9]{2}_[0-9]{6}Z_[a-z][a-z0-9-]*_[a-z][a-z0-9-]+\.md$/;
+/**
+* Recursively collects `.md` files under `targetPath`, excluding anything inside a `templates/`
+* subdirectory. When `targetPath` is a single file, returns it directly.
+*/
+async function findMarkdownFiles(targetPath) {
+	if (!(await fs.stat(targetPath)).isDirectory()) return [targetPath];
+	const results = [];
+	const queue = [targetPath];
+	while (queue.length > 0) {
+		const dir = queue.shift();
+		const entries = await fs.readdir(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				if (entry.name === "templates") continue;
+				queue.push(fullPath);
+			} else if (entry.isFile() && entry.name.endsWith(".md")) results.push(fullPath);
+		}
+	}
+	return results.sort();
+}
+async function validate(_flags, targetPath = ".agent-logbook") {
+	const absoluteTargetPath = path.resolve(this.workspacesRoot, targetPath);
+	const typeboxValidate = Compile(FrontmatterSchema);
+	const files = await findMarkdownFiles(absoluteTargetPath);
+	let failed = 0;
+	const filePromises = files.map(async (file) => {
+		const filename = path.basename(file);
+		if (!FILENAME_RE.test(filename)) {
+			console.error(`FAIL (filename) ${file}`);
+			failed++;
+			return;
+		}
+		const { data } = matter(await fs.readFile(file, "utf8"), { engines: { yaml: {
+			parse: (text) => yaml.parse(text),
+			stringify: (data) => yaml.stringify(data)
+		} } });
+		if (!typeboxValidate.Check(data)) {
+			console.error(`FAIL (schema) ${file}`);
+			const errors = typeboxValidate.Errors(data);
+			for (const error of errors) console.error(`  ${error.instancePath || "(root)"} ${error.message}`);
+			failed++;
+		}
+	});
+	await Promise.all(filePromises);
+	if (failed > 0) return process.exit(1);
+	console.log("All files validated successfully");
+}
+
+//#endregion
+export { validate };

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@stzhu/skills",
+  "version": "0.1.0",
+  "description": "Skills CLI",
+  "keywords": [
+    "skills"
+  ],
+  "license": "MIT",
+  "author": "Steve Zhu <4130171+stevezhu@users.noreply.github.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stevezhu/eslint-config.git"
+  },
+  "bin": {
+    "__stz-skills_bash_complete": "dist/bash-complete.mjs",
+    "stz-skills": "dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "imports": {
+    "#*": "./src/*"
+  },
+  "dependencies": {
+    "@stricli/auto-complete": "^1.2.6",
+    "@stricli/core": "^1.2.6",
+    "find-workspaces": "^0.3.1",
+    "gray-matter": "^4.0.3",
+    "typebox": "^1.1.5",
+    "yaml": "^2.8.2"
+  },
+  "devDependencies": {
+    "@stzhu/tsconfig": "^0.1.1",
+    "@types/node": "^25.3.3",
+    "oxfmt": "^0.36.0",
+    "oxlint": "^1.51.0",
+    "oxlint-tsgolint": "^0.16.0",
+    "tsdown": "^0.20.3",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=25"
+  },
+  "scripts": {
+    "ai:claude": "claude",
+    "ai:gemini": "SEATBELT_PROFILE=custom gemini",
+    "build": "tsdown",
+    "format": "oxfmt",
+    "format:check": "oxfmt --check",
+    "lint": "pnpm run format:check && oxlint --type-aware",
+    "lint:fix": "oxlint --type-aware --fix",
+    "postinstall": "([ ! -d \"src\" ] || pnpm run build) && node dist/cli.mjs install",
+    "pretest": "tsc --noEmit",
+    "test": "vitest"
+  }
+}