tokenmog 0.0.0-stage → 0.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +41 -2
- package/deck.js +274 -0
- package/package.json +26 -4
package/LICENSE
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
1
|
+
MIT License
|
|
2
|
+
|
|
3
|
+
Copyright (c) 2026 Siempi AG
|
|
4
|
+
|
|
5
|
+
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
6
|
+
of this software and associated documentation files (the "Software"), to deal
|
|
7
|
+
in the Software without restriction, including without limitation the rights
|
|
8
|
+
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
9
|
+
copies of the Software, and to permit persons to whom the Software is
|
|
10
|
+
furnished to do so, subject to the following conditions:
|
|
11
|
+
|
|
12
|
+
The above copyright notice and this permission notice shall be included in all
|
|
13
|
+
copies or substantial portions of the Software.
|
|
14
|
+
|
|
15
|
+
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
16
|
+
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
17
|
+
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
18
|
+
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
19
|
+
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
20
|
+
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
21
|
+
SOFTWARE.
|
package/README.md
CHANGED
|
@@ -1,3 +1,42 @@
|
|
|
1
|
-
#
|
|
1
|
+
# tokenmog
|
|
2
2
|
|
|
3
|
-
|
|
3
|
+
Deals your deck for [Tokenmog](https://siempi.ch), the two-player card game played with your own Claude Code usage.
|
|
4
|
+
|
|
5
|
+
```
|
|
6
|
+
npx tokenmog
|
|
7
|
+
```
|
|
8
|
+
|
|
9
|
+
It counts your last 30 days of Claude Code sessions on your own computer and opens the game with your deck.
|
|
10
|
+
|
|
11
|
+
> **The game is not live yet.** This first release reserves the name. Until the table opens, `npx tokenmog --dry-run` already shows your twelve cards in the terminal.
|
|
12
|
+
|
|
13
|
+
## See it first
|
|
14
|
+
|
|
15
|
+
```
|
|
16
|
+
npx tokenmog --dry-run
|
|
17
|
+
```
|
|
18
|
+
|
|
19
|
+
prints exactly what would be shared, card by card, and opens nothing.
|
|
20
|
+
|
|
21
|
+
## What is shared with the game
|
|
22
|
+
|
|
23
|
+
- how many sessions you had in the last 30 days, with their total tokens, tool calls and cache use
|
|
24
|
+
- for up to twelve sessions: tokens, tool calls, prompts, tokens read from the prompt cache, the model's name, the day it started, the minutes it was worked on, the kind of tool it used most (Bash, Edit, Read, Search, Web, Agent or MCP), and how often it compacted or started subagents
|
|
25
|
+
|
|
26
|
+
These numbers travel in the part of the link after `#`, which a browser never sends to a server. Nothing is uploaded. An opponent sees your totals at the start of a match and each card when you play it.
|
|
27
|
+
|
|
28
|
+
## What is never read out or shared
|
|
29
|
+
|
|
30
|
+
Prompts, replies, file names, folder names, project names, session IDs and the names of your tools or connected services. The script changes no file and has no network code: it is one file, `deck.js`, with no dependencies.
|
|
31
|
+
|
|
32
|
+
## Run a known version
|
|
33
|
+
|
|
34
|
+
The game shows this command with an exact version, such as `npx tokenmog@0.0.1`. A published version can never be changed afterwards, so the code you run is the code that version always had. The package has no dependencies and no install scripts.
|
|
35
|
+
|
|
36
|
+
## Options
|
|
37
|
+
|
|
38
|
+
- `--dry-run` show what would be shared and open nothing
|
|
39
|
+
- `--no-open` print the link instead of opening the browser
|
|
40
|
+
- `--help`
|
|
41
|
+
|
|
42
|
+
Needs Node.js 18 or newer. Tokenmog is made by Siempi AG and is not affiliated with Anthropic.
|
package/deck.js
ADDED
|
@@ -0,0 +1,274 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
/*
|
|
3
|
+
* Tokenmog: deals your deck from your own Claude Code usage.
|
|
4
|
+
*
|
|
5
|
+
* It reads the session logs that Claude Code keeps in ~/.claude/projects, adds up a few numbers
|
|
6
|
+
* per session, and opens the game with those numbers in the link.
|
|
7
|
+
*
|
|
8
|
+
* What it does not do:
|
|
9
|
+
* - It sends nothing anywhere. There is no network code in this file. The numbers travel in the
|
|
10
|
+
* part of the link after "#", which a browser keeps to itself and never sends to a server.
|
|
11
|
+
* - It keeps no prompt, reply, file name, folder name, project name or session ID. Only the
|
|
12
|
+
* numbers it prints, the kind of tool a session used most and the names of models leave it.
|
|
13
|
+
* - It changes no file.
|
|
14
|
+
*
|
|
15
|
+
* Run it with --dry-run to see exactly what would be shared without opening anything.
|
|
16
|
+
*/
|
|
17
|
+
'use strict';
|
|
18
|
+
|
|
19
|
+
const fs = require('fs');
|
|
20
|
+
const os = require('os');
|
|
21
|
+
const path = require('path');
|
|
22
|
+
const { spawnSync } = require('child_process');
|
|
23
|
+
|
|
24
|
+
const DAYS = 30;
|
|
25
|
+
const DECK = 12;
|
|
26
|
+
const EDGE = 1500; // enough of a line's start or end to tell what kind of entry it is
|
|
27
|
+
const SMALL = 64 * 1024; // lines from the person up to this size are read whole
|
|
28
|
+
const LIMIT = 16 * 1024 * 1024;
|
|
29
|
+
const IDLE = 10 * 60000; // a gap longer than this is a break, not work
|
|
30
|
+
|
|
31
|
+
// The game's live address. Empty until the game is deployed: this release then says so and opens nothing.
|
|
32
|
+
// Set TOKENMOG_URL to point the command at a development copy.
|
|
33
|
+
const HOME_URL = '';
|
|
34
|
+
const GAME_URL = process.env.TOKENMOG_URL || HOME_URL;
|
|
35
|
+
|
|
36
|
+
const args = process.argv.slice(2);
|
|
37
|
+
const has = (...names) => names.some((n) => args.includes(n));
|
|
38
|
+
const DRY_RUN = has('--dry-run', '--preview');
|
|
39
|
+
const NO_OPEN = has('--no-open') || !!process.env.TOKENMOG_NO_OPEN;
|
|
40
|
+
|
|
41
|
+
const root = path.join(process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude'), 'projects');
|
|
42
|
+
const num = (v) => (typeof v === 'number' && Number.isFinite(v) && v > 0 ? v : 0);
|
|
43
|
+
|
|
44
|
+
/** Every .jsonl log under the folder that was written to in the last 30 days. */
|
|
45
|
+
function recentLogs(dir, since, out = []) {
|
|
46
|
+
let entries = [];
|
|
47
|
+
try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return out; }
|
|
48
|
+
for (const e of entries) {
|
|
49
|
+
const p = path.join(dir, e.name);
|
|
50
|
+
if (e.isDirectory()) recentLogs(p, since, out);
|
|
51
|
+
else if (e.name.endsWith('.jsonl')) {
|
|
52
|
+
try { if (fs.statSync(p).mtimeMs >= since) out.push(p); } catch { /* unreadable: skip */ }
|
|
53
|
+
}
|
|
54
|
+
}
|
|
55
|
+
return out;
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
/** A subagent's log counts towards the session that started it. */
|
|
59
|
+
function sessionOf(file) {
|
|
60
|
+
const parts = file.split(path.sep);
|
|
61
|
+
const sub = parts.lastIndexOf('subagents');
|
|
62
|
+
return sub > 0 ? parts[sub - 1] : path.basename(file, '.jsonl');
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
/** Tools are reported by kind only, so the name of a connected service never leaves this script. */
|
|
66
|
+
function kindOf(tool) {
|
|
67
|
+
if (/^Bash/.test(tool)) return 'Bash';
|
|
68
|
+
if (/^(Edit|Write|MultiEdit|NotebookEdit)$/.test(tool)) return 'Edit';
|
|
69
|
+
if (tool === 'Read') return 'Read';
|
|
70
|
+
if (/^(Grep|Glob|LS)$/.test(tool)) return 'Search';
|
|
71
|
+
if (/^Web/.test(tool)) return 'Web';
|
|
72
|
+
if (/^(Task|Agent)$/.test(tool)) return 'Agent';
|
|
73
|
+
if (/^mcp__/.test(tool)) return 'MCP';
|
|
74
|
+
return 'Other';
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
/** Only what a person typed counts as a prompt: not notices, command output or reminders the app adds. */
|
|
78
|
+
function typed(text) {
|
|
79
|
+
const t = text.trimStart();
|
|
80
|
+
if (!t) return false;
|
|
81
|
+
if (t.startsWith('<command-name>') || t.startsWith('<command-message>') || t.startsWith('<bash-input>')) return true;
|
|
82
|
+
return !t.startsWith('<') && !t.startsWith('[Request interrupted') && !t.startsWith('Caveat:') && !t.startsWith('This session is being continued');
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
/** Adds one log entry to its session. Only counts are kept; the text of the entry is dropped. */
|
|
86
|
+
function count(s, entry, assistant, sub, since, seen) {
|
|
87
|
+
const m = entry && entry.message;
|
|
88
|
+
if (!m || typeof m !== 'object') return;
|
|
89
|
+
const at = typeof entry.timestamp === 'string' ? Date.parse(entry.timestamp) : 0;
|
|
90
|
+
if (at && at < since) return; // older than the 30 days, even though the log file is recent
|
|
91
|
+
if (at) {
|
|
92
|
+
if (!s.first || at < s.first) s.first = at;
|
|
93
|
+
if (s.prev && at > s.prev && at - s.prev < IDLE) s.active += at - s.prev;
|
|
94
|
+
if (at > s.prev) s.prev = at;
|
|
95
|
+
}
|
|
96
|
+
const blocks = Array.isArray(m.content) ? m.content : [];
|
|
97
|
+
|
|
98
|
+
if (!assistant) {
|
|
99
|
+
if (entry.isCompactSummary) { s.compactions++; return; }
|
|
100
|
+
if (sub || entry.isMeta || blocks.some((b) => b && b.type === 'tool_result')) return;
|
|
101
|
+
const text = typeof m.content === 'string' ? m.content : (blocks.find((b) => b && b.type === 'text') || {}).text || '';
|
|
102
|
+
if (typed(text)) s.prompts++;
|
|
103
|
+
return;
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
for (const b of blocks) {
|
|
107
|
+
if (!b || b.type !== 'tool_use') continue;
|
|
108
|
+
s.tools++;
|
|
109
|
+
const kind = kindOf(String(b.name || ''));
|
|
110
|
+
s.kinds[kind] = (s.kinds[kind] || 0) + 1;
|
|
111
|
+
}
|
|
112
|
+
// One reply is written as several lines that repeat the same usage, so each reply is counted once.
|
|
113
|
+
const u = m.usage;
|
|
114
|
+
const id = typeof m.id === 'string' ? m.id : '';
|
|
115
|
+
if (!u || typeof u !== 'object' || (id && seen.has(id))) return;
|
|
116
|
+
if (id) seen.add(id);
|
|
117
|
+
const read = num(u.cache_read_input_tokens);
|
|
118
|
+
const input = num(u.input_tokens) + num(u.cache_creation_input_tokens) + read;
|
|
119
|
+
const total = input + num(u.output_tokens);
|
|
120
|
+
s.read += read;
|
|
121
|
+
s.input += input;
|
|
122
|
+
s.tokens += total;
|
|
123
|
+
if (typeof m.model === 'string' && m.model && !m.model.startsWith('<')) s.models.set(m.model, (s.models.get(m.model) || 0) + total);
|
|
124
|
+
}
|
|
125
|
+
|
|
126
|
+
/**
|
|
127
|
+
* Reads one log line by line. Claude's replies carry their type at the end of the line and the
|
|
128
|
+
* person's entries carry it at the start, so only the two ends of a line are looked at to decide
|
|
129
|
+
* what it is. Very long lines from the person (pasted files, tool output) are never read whole.
|
|
130
|
+
*/
|
|
131
|
+
async function readLog(file, s, sub, since, seen) {
|
|
132
|
+
let parts = [];
|
|
133
|
+
let size = 0;
|
|
134
|
+
const line = () => {
|
|
135
|
+
const whole = Buffer.concat(parts);
|
|
136
|
+
const head = whole.subarray(0, EDGE).toString('utf8');
|
|
137
|
+
const user = head.includes('"type":"user"');
|
|
138
|
+
const assistant = !user && size <= LIMIT && whole.subarray(Math.max(0, whole.length - EDGE)).toString('utf8').includes('"type":"assistant"');
|
|
139
|
+
if (assistant || (user && size <= SMALL)) {
|
|
140
|
+
try { count(s, JSON.parse(whole.toString('utf8')), assistant, sub, since, seen); } catch { /* a cut-off line */ }
|
|
141
|
+
}
|
|
142
|
+
parts = [];
|
|
143
|
+
size = 0;
|
|
144
|
+
};
|
|
145
|
+
for await (const chunk of fs.createReadStream(file, { highWaterMark: 1 << 20 })) {
|
|
146
|
+
let from = 0;
|
|
147
|
+
for (;;) {
|
|
148
|
+
const nl = chunk.indexOf(10, from);
|
|
149
|
+
if (nl < 0) break;
|
|
150
|
+
if (size <= LIMIT) parts.push(chunk.subarray(from, nl));
|
|
151
|
+
size += nl - from;
|
|
152
|
+
line();
|
|
153
|
+
from = nl + 1;
|
|
154
|
+
}
|
|
155
|
+
if (from < chunk.length) {
|
|
156
|
+
if (size <= LIMIT) parts.push(chunk.subarray(from));
|
|
157
|
+
size += chunk.length - from;
|
|
158
|
+
}
|
|
159
|
+
}
|
|
160
|
+
if (size) line();
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
/** Opens the link in the default browser. False when that is not possible, and the link is printed instead. */
|
|
164
|
+
function open(link) {
|
|
165
|
+
const [cmd, ...rest] = process.platform === 'darwin' ? ['open', link] : process.platform === 'win32' ? ['cmd', '/c', 'start', '""', link] : ['xdg-open', link];
|
|
166
|
+
try { return spawnSync(cmd, rest, { stdio: 'ignore' }).status === 0; } catch { return false; }
|
|
167
|
+
}
|
|
168
|
+
|
|
169
|
+
/** A checksum, so a code that was edited by hand is noticed. It is not a secret: it only keeps honest players honest. */
|
|
170
|
+
function check(text) {
|
|
171
|
+
let h = 2166136261;
|
|
172
|
+
for (const ch of `tokenmog/1:${text}`) h = Math.imul(h ^ ch.charCodeAt(0), 16777619);
|
|
173
|
+
return (h >>> 0).toString(16).padStart(8, '0');
|
|
174
|
+
}
|
|
175
|
+
|
|
176
|
+
const big = (v) => (v >= 1e9 ? `${(v / 1e9).toFixed(2)}B` : v >= 1e6 ? `${(v / 1e6).toFixed(1)}M` : `${Math.round(v / 1e3)}k`);
|
|
177
|
+
|
|
178
|
+
const HELP = `Tokenmog: deals your deck from your own Claude Code usage and opens the game.
|
|
179
|
+
|
|
180
|
+
--dry-run show exactly what would be shared, and open nothing
|
|
181
|
+
--no-open print the link instead of opening the browser
|
|
182
|
+
--help show this
|
|
183
|
+
|
|
184
|
+
It reads the Claude Code session logs on this computer. Nothing is uploaded.`;
|
|
185
|
+
|
|
186
|
+
async function main() {
|
|
187
|
+
if (has('--help', '-h')) return console.log(HELP);
|
|
188
|
+
if (!fs.existsSync(root)) {
|
|
189
|
+
console.error(`No Claude Code logs found at ${root}. Run this on the computer where you use Claude Code.`);
|
|
190
|
+
process.exit(1);
|
|
191
|
+
}
|
|
192
|
+
const since = Date.now() - DAYS * 864e5;
|
|
193
|
+
const files = recentLogs(root, since);
|
|
194
|
+
const sessions = new Map();
|
|
195
|
+
const seen = new Set(); // reply ids, so a reply copied into a resumed session is not counted again
|
|
196
|
+
for (const file of files) {
|
|
197
|
+
const id = sessionOf(file);
|
|
198
|
+
if (!sessions.has(id)) sessions.set(id, { tokens: 0, read: 0, input: 0, tools: 0, prompts: 0, compactions: 0, subagents: 0, first: 0, prev: 0, active: 0, kinds: {}, models: new Map() });
|
|
199
|
+
const s = sessions.get(id);
|
|
200
|
+
const sub = file.split(path.sep).includes('subagents');
|
|
201
|
+
if (sub) s.subagents++;
|
|
202
|
+
await readLog(file, s, sub, since, seen);
|
|
203
|
+
}
|
|
204
|
+
|
|
205
|
+
const all = [...sessions.values()].filter((s) => s.tokens > 0).map((s) => ({
|
|
206
|
+
tokens: s.tokens, tools: s.tools, prompts: s.prompts, read: s.read, input: s.input,
|
|
207
|
+
model: ([...s.models.entries()].sort((a, b) => b[1] - a[1])[0] || [''])[0],
|
|
208
|
+
started: Math.floor(s.first / 60000), minutes: Math.max(1, Math.round(s.active / 60000)),
|
|
209
|
+
tool: (Object.entries(s.kinds).sort((a, b) => b[1] - a[1])[0] || [''])[0],
|
|
210
|
+
compactions: s.compactions, subagents: s.subagents,
|
|
211
|
+
autonomy: s.prompts ? s.tools / s.prompts : 0, cache: s.input ? s.read / s.input : 0,
|
|
212
|
+
}));
|
|
213
|
+
const playable = all.filter((s) => s.tokens >= 20000 && s.prompts >= 1 && s.input > 0);
|
|
214
|
+
if (!playable.length) {
|
|
215
|
+
console.error('No Claude Code sessions from the last 30 days were found, so there is no deck to deal yet.');
|
|
216
|
+
process.exit(1);
|
|
217
|
+
}
|
|
218
|
+
|
|
219
|
+
// The deck is the three best sessions at each of the four stats.
|
|
220
|
+
const picked = [];
|
|
221
|
+
const stats = ['tokens', 'tools', 'autonomy', 'cache'];
|
|
222
|
+
for (let lap = 0; picked.length < Math.min(DECK, playable.length); lap++) {
|
|
223
|
+
const key = stats[lap % stats.length];
|
|
224
|
+
const next = playable.filter((s) => !picked.includes(s)).sort((a, b) => b[key] - a[key])[0];
|
|
225
|
+
if (next) picked.push(next);
|
|
226
|
+
}
|
|
227
|
+
|
|
228
|
+
const total = (k) => all.reduce((n, s) => n + s[k], 0);
|
|
229
|
+
const body = JSON.stringify({
|
|
230
|
+
v: 2,
|
|
231
|
+
days: DAYS,
|
|
232
|
+
sessions: all.length,
|
|
233
|
+
tokens: total('tokens'),
|
|
234
|
+
tools: total('tools'),
|
|
235
|
+
read: total('read'),
|
|
236
|
+
input: total('input'),
|
|
237
|
+
// Each card: tokens, tool calls, prompts, cache-read tokens, input tokens, model, start (minutes
|
|
238
|
+
// since 1970), minutes worked, most-used kind of tool, compactions, subagents.
|
|
239
|
+
cards: picked.map((s) => [s.tokens, s.tools, s.prompts, s.read, s.input, s.model, s.started, s.minutes, s.tool, s.compactions, s.subagents]),
|
|
240
|
+
});
|
|
241
|
+
const code = `tokenmog:${body.slice(0, -1)},"check":"${check(body)}"}`;
|
|
242
|
+
|
|
243
|
+
const pct = (read, input) => `${(input ? (100 * read) / input : 0).toFixed(1)}%`;
|
|
244
|
+
console.log(`\nTokenmog read ${files.length} Claude Code log files from the last ${DAYS} days, on this computer.\n`);
|
|
245
|
+
console.log('Shared with the game (in the link; nothing is uploaded):');
|
|
246
|
+
console.log(` ${all.length} sessions, ${big(total('tokens'))} tokens, ${total('tools').toLocaleString('en-US')} tool calls, ${pct(total('read'), total('input'))} cache hit`);
|
|
247
|
+
console.log(` ${picked.length} sessions as cards: tokens, tool calls, prompts, cache use, model, day, minutes worked,`);
|
|
248
|
+
console.log(' most-used kind of tool, compactions, subagents');
|
|
249
|
+
console.log('Never read out or shared:');
|
|
250
|
+
console.log(' prompts, replies, file names, project names, session IDs, tool names\n');
|
|
251
|
+
|
|
252
|
+
if (DRY_RUN) {
|
|
253
|
+
const day = (m) => new Date(m * 60000).toISOString().slice(5, 10);
|
|
254
|
+
console.log(' card tokens tool calls prompts cache hit day minutes mostly compactions subagents model');
|
|
255
|
+
picked.forEach((s, i) => console.log(` ${String(i + 1).padStart(4)} ${big(s.tokens).padStart(10)} ${String(s.tools).padStart(11)} ${String(s.prompts).padStart(8)} ${pct(s.read, s.input).padStart(10)} ${day(s.started)} ${String(s.minutes).padStart(8)} ${(s.tool || '-').padEnd(6)} ${String(s.compactions).padStart(11)} ${String(s.subagents).padStart(10)} ${s.model || 'unknown'}`));
|
|
256
|
+
console.log('\nDry run: nothing was opened and nothing left this computer.\n');
|
|
257
|
+
return;
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
if (!GAME_URL) {
|
|
261
|
+
console.log('Tokenmog is not live yet, so there is no table to open your deck at.');
|
|
262
|
+
console.log('Run it again with --dry-run to see your twelve cards. Nothing left this computer.\n');
|
|
263
|
+
return;
|
|
264
|
+
}
|
|
265
|
+
|
|
266
|
+
const link = `${GAME_URL}/#code=${encodeURIComponent(code)}`;
|
|
267
|
+
if (!NO_OPEN && open(link)) console.log('Your deck is opening in your browser.\n');
|
|
268
|
+
else console.log(`Open this link to play with your deck:\n${link}\n`);
|
|
269
|
+
}
|
|
270
|
+
|
|
271
|
+
main().catch((e) => {
|
|
272
|
+
console.error('Tokenmog could not read the logs:', e.message);
|
|
273
|
+
process.exit(1);
|
|
274
|
+
});
|
package/package.json
CHANGED
|
@@ -1,6 +1,28 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "tokenmog",
|
|
3
|
-
"version": "0.0.
|
|
4
|
-
"
|
|
5
|
-
"
|
|
6
|
-
|
|
3
|
+
"version": "0.0.1",
|
|
4
|
+
"description": "Deals your Tokenmog deck from your own Claude Code usage and opens the game. Reads only numbers; uploads nothing.",
|
|
5
|
+
"bin": {
|
|
6
|
+
"tokenmog": "deck.js"
|
|
7
|
+
},
|
|
8
|
+
"files": [
|
|
9
|
+
"deck.js"
|
|
10
|
+
],
|
|
11
|
+
"engines": {
|
|
12
|
+
"node": ">=18"
|
|
13
|
+
},
|
|
14
|
+
"keywords": [
|
|
15
|
+
"claude-code",
|
|
16
|
+
"claude",
|
|
17
|
+
"usage",
|
|
18
|
+
"tokens",
|
|
19
|
+
"card-game",
|
|
20
|
+
"cli"
|
|
21
|
+
],
|
|
22
|
+
"homepage": "https://siempi.ch",
|
|
23
|
+
"author": "Siempi AG (https://siempi.ch)",
|
|
24
|
+
"license": "MIT",
|
|
25
|
+
"publishConfig": {
|
|
26
|
+
"access": "public"
|
|
27
|
+
}
|
|
28
|
+
}
|