tokwise 0.1.0

package/dist/tiktok.js

@@ -0,0 +1,445 @@
+import { stableHash, uniqueStrings } from "./store.js";
+async function loadApi() {
+    const mod = (await import("@tobyg74/tiktok-api-dl"));
+    return mod.default ?? mod;
+}
+export async function fetchCollection(idOrUrl, options) {
+    const normalized = normalizeCollectionInput(idOrUrl, options.username);
+    if (!normalized.collectionId && !normalized.collectionUrl) {
+        throw new Error(`Cannot resolve collection "${idOrUrl}". Use a full URL, @user/collection/slug, or run \`tw auth set-username <handle>\`.`);
+    }
+    const resolved = normalized.collectionUrl ?? normalized.collectionId ?? idOrUrl;
+    const context = {
+        source: "collection",
+        collectionId: normalized.collectionId,
+        collectionUrl: normalized.collectionUrl,
+    };
+    if (options.cookie) {
+        return fetchPaged(fetchCollectionWithCookie, resolved, options, context);
+    }
+    const api = await loadApi();
+    const fn = requireFunction(api, "Collection");
+    return fetchPaged(fn, resolved, options, context);
+}
+export async function fetchPlaylist(idOrUrl, options) {
+    const api = await loadApi();
+    const fn = requireFunction(api, "Playlist");
+    return fetchPaged(fn, idOrUrl, options, {
+        source: "playlist",
+        collectionId: inferTrailingId(idOrUrl),
+        collectionUrl: looksLikeUrl(idOrUrl) ? idOrUrl : undefined,
+    });
+}
+export async function fetchLiked(username, options) {
+    const api = await loadApi();
+    const fn = requireFunction(api, "GetUserLiked");
+    return fetchPaged(fn, username, options, {
+        source: "liked",
+        collectionName: `${username} liked videos`,
+        collectionId: username,
+    });
+}
+export async function fetchUserPosts(username, options) {
+    const api = await loadApi();
+    const fn = requireFunction(api, "GetUserPosts");
+    return fetchPaged(fn, username, options, {
+        source: "user",
+        collectionName: `${username} posts`,
+        collectionId: username,
+    });
+}
+export async function fetchVideoSearch(query, options) {
+    const api = await loadApi();
+    const fn = requireFunction(api, "Search");
+    const response = await fn(query, {
+        type: "video",
+        page: options.page ?? 1,
+        cookie: options.cookie,
+        proxy: options.proxy,
+    });
+    return extractItems(response)
+        .slice(0, options.limit)
+        .map((item) => normalizeVideo(item, {
+        source: "search",
+        collectionName: `Search: ${query}`,
+        collectionId: query,
+    }));
+}
+export async function fetchSingleUrl(url, options) {
+    const api = await loadApi();
+    const fn = requireFunction(api, "Downloader");
+    const response = await fn(url, {
+        version: "v1",
+        proxy: options.proxy,
+        showOriginalResponse: true,
+    });
+    const items = extractItems(response);
+    const responseRecord = asRecord(response);
+    const item = items[0] ?? asRecord(responseRecord?.result) ?? responseRecord ?? {};
+    return normalizeVideo({ ...item, url }, { source: "url" });
+}
+export function videosFromUrls(urls) {
+    return urls.map((url) => normalizeVideo({ id: inferVideoId(url) ?? stableHash(url), url }, { source: "url" }));
+}
+export function videosFromImport(value) {
+    if (Array.isArray(value))
+        return value.map((item) => normalizeVideo(asRecord(item) ?? { value: item }, { source: "import" }));
+    if (isRecord(value) && Array.isArray(value.items)) {
+        return value.items.map((item) => normalizeVideo(asRecord(item) ?? { value: item }, { source: "import" }));
+    }
+    if (isRecord(value) && Array.isArray(value.result)) {
+        return value.result.map((item) => normalizeVideo(asRecord(item) ?? { value: item }, { source: "import" }));
+    }
+    const record = asRecord(value);
+    return record ? [normalizeVideo(record, { source: "import" })] : [];
+}
+async function fetchPaged(fn, idOrUrl, options, context) {
+    const limit = options.limit ?? 30;
+    const pageStart = options.page ?? 1;
+    const maxPages = options.pages ?? Math.ceil(limit / 30);
+    const videos = [];
+    let page = pageStart;
+    for (let i = 0; i < maxPages && videos.length < limit; i += 1) {
+        const response = await fn(idOrUrl, {
+            page,
+            count: Math.min(30, limit - videos.length),
+            postLimit: Math.min(30, limit - videos.length),
+            cookie: options.cookie,
+            proxy: options.proxy,
+        });
+        const items = extractItemsFromSuccessfulResponse(response, context.source);
+        videos.push(...items.map((item) => normalizeVideo(item, context)));
+        if (!hasMore(response) || items.length === 0)
+            break;
+        page += 1;
+    }
+    return dedupeById(videos).slice(0, limit);
+}
+function requireFunction(api, name) {
+    const value = api[name];
+    if (typeof value !== "function") {
+        throw new Error(`@tobyg74/tiktok-api-dl does not expose ${name}().`);
+    }
+    return value;
+}
+async function fetchCollectionWithCookie(idOrUrl, options) {
+    const collectionId = inferCollectionId(idOrUrl);
+    if (!collectionId) {
+        return {
+            status: "error",
+            message: "Invalid collection ID or URL format",
+        };
+    }
+    const page = numberValue(options.page) ?? 1;
+    const count = numberValue(options.count) ?? 30;
+    const cursor = Math.max(0, page - 1) * count;
+    const params = new URLSearchParams({
+        WebIdLastTime: String(Date.now()),
+        aid: "1988",
+        app_language: "en",
+        app_name: "tiktok_web",
+        browser_language: "en-US",
+        browser_name: "Mozilla",
+        browser_online: "true",
+        browser_platform: "MacIntel",
+        browser_version: "5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+        channel: "tiktok_web",
+        collectionId,
+        cookie_enabled: "true",
+        count: String(count),
+        cursor: String(cursor),
+        device_platform: "web_pc",
+        focus_state: "true",
+        from_page: "user",
+        history_len: "3",
+        is_fullscreen: "false",
+        is_page_visible: "true",
+        language: "en",
+        os: "mac",
+        referer: looksLikeUrl(idOrUrl) ? idOrUrl : "",
+        sourceType: "113",
+        tz_name: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
+        user_is_login: "true",
+        webcast_language: "en",
+    });
+    const response = await fetch(`https://www.tiktok.com/api/collection/item_list/?${params.toString()}`, {
+        method: "GET",
+        headers: {
+            "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+            accept: "application/json, text/plain, */*",
+            "accept-language": "en-US,en;q=0.9",
+            cookie: String(options.cookie ?? ""),
+            referer: looksLikeUrl(idOrUrl) ? idOrUrl : "https://www.tiktok.com/",
+        },
+    });
+    if (!response.ok) {
+        return {
+            status: "error",
+            message: `Source returned HTTP ${response.status} ${response.statusText}`,
+        };
+    }
+    return response.json();
+}
+export function extractUsernameFromRehydrationHtml(html) {
+    const match = html.match(/__UNIVERSAL_DATA_FOR_REHYDRATION__"[^>]*>(.*?)<\/script>/s);
+    if (!match || !match[1])
+        return undefined;
+    try {
+        const data = asRecord(JSON.parse(match[1]));
+        const scope = asRecord(data?.["__DEFAULT_SCOPE__"]);
+        const appContext = asRecord(scope?.["webapp.app-context"]);
+        const user = asRecord(appContext?.user);
+        return stringValue(user?.uniqueId);
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function detectLoggedInUsername(cookie, proxy) {
+    if (!cookie)
+        return undefined;
+    try {
+        const response = await fetch("https://www.tiktok.com/", {
+            method: "GET",
+            headers: {
+                "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+                accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                "accept-language": "en-US,en;q=0.9",
+                cookie,
+            },
+        });
+        if (!response.ok)
+            return undefined;
+        return extractUsernameFromRehydrationHtml(await response.text());
+    }
+    catch {
+        return undefined;
+    }
+}
+export function extractItemsFromSuccessfulResponse(response, source) {
+    assertSuccessfulResponse(response, source);
+    return extractItems(response).filter(isLikelyVideoItem);
+}
+function assertSuccessfulResponse(response, source) {
+    const root = asRecord(response);
+    if (!root)
+        return;
+    const status = stringValue(root.status);
+    const statusCode = numberValue(root.statusCode) ?? numberValue(root.status_code);
+    if (status === "error" || (statusCode != null && statusCode !== 0)) {
+        const message = stringValue(root.message) ?? stringValue(root.statusMsg) ?? stringValue(root.status_msg) ?? "unknown error";
+        throw new Error(`Source ${source} fetch failed: ${message}`);
+    }
+}
+function extractItems(response) {
+    const root = asRecord(response);
+    if (!root)
+        return [];
+    const result = asRecord(root.result);
+    const candidates = [
+        root.itemList,
+        root.collectionItemList,
+        root.item_list,
+        root.aweme_list,
+        root.items,
+        root.videos,
+        root.result,
+        result?.itemList,
+        result?.collectionItemList,
+        result?.item_list,
+        result?.aweme_list,
+        result?.items,
+        result?.videos,
+    ];
+    for (const candidate of candidates) {
+        if (Array.isArray(candidate))
+            return candidate.flatMap((item) => (asRecord(item) ? [asRecord(item)] : []));
+    }
+    if (result)
+        return [result];
+    return [root];
+}
+function isLikelyVideoItem(item) {
+    const id = stringValue(item.id) ?? stringValue(item.awemeId) ?? stringValue(item.aweme_id);
+    if (id && /^\d{8,}$/.test(id))
+        return true;
+    const url = stringValue(item.url) ?? stringValue(item.shareUrl);
+    return Boolean(inferVideoId(url));
+}
+function hasMore(response) {
+    const root = asRecord(response);
+    const result = asRecord(root?.result);
+    const value = result?.hasMore ?? root?.hasMore;
+    return value === true || value === "true";
+}
+export function normalizeVideo(item, context) {
+    const id = stringValue(item.id) ?? stringValue(item.awemeId) ?? stringValue(item.aweme_id) ?? inferVideoId(stringValue(item.url)) ?? stableHash(JSON.stringify(item));
+    const authorRecord = asRecord(item.author) ?? asRecord(item.owner);
+    const statsRecord = asRecord(item.stats) ?? asRecord(item.statistics);
+    const videoRecord = asRecord(item.video);
+    const musicRecord = asRecord(item.music);
+    const textExtra = Array.isArray(item.textExtra) ? item.textExtra.flatMap((entry) => (asRecord(entry) ? [entry] : [])) : [];
+    const challenges = Array.isArray(item.challenges) ? item.challenges.flatMap((entry) => (asRecord(entry) ? [entry] : [])) : [];
+    const hashtags = uniqueStrings([
+        ...arrayOfStrings(item.hashtag),
+        ...textExtra.map((entry) => stringValue(entry.hashtagName)),
+        ...challenges.map((entry) => stringValue(entry.title)),
+    ]);
+    const username = stringValue(authorRecord?.username) ??
+        stringValue(authorRecord?.uniqueId) ??
+        stringValue(item.username) ??
+        inferUsername(stringValue(item.url));
+    const url = stringValue(item.url) ?? stringValue(item.shareUrl) ?? (username ? `https://www.tiktok.com/@${username}/video/${id}` : `https://www.tiktok.com/video/${id}`);
+    const createdAt = toIsoTime(item.createTime);
+    const now = new Date().toISOString();
+    const raw = JSON.parse(JSON.stringify(item));
+    return {
+        id,
+        url,
+        canonicalUrl: username ? `https://www.tiktok.com/@${username}/video/${id}` : url,
+        description: stringValue(item.desc) ?? stringValue(item.description) ?? stringValue(item.title),
+        createdAt,
+        savedAt: now,
+        syncedAt: now,
+        source: context.source,
+        collection: {
+            source: context.source,
+            id: context.collectionId,
+            name: context.collectionName,
+            url: context.collectionUrl,
+        },
+        author: {
+            id: stringValue(authorRecord?.id) ?? stringValue(authorRecord?.uid),
+            username,
+            displayName: stringValue(authorRecord?.nickname) ?? stringValue(authorRecord?.displayName),
+            signature: stringValue(authorRecord?.signature),
+            verified: booleanValue(authorRecord?.verified),
+            avatarUrl: firstString(authorRecord?.avatarThumb) ?? firstString(authorRecord?.avatarMedium) ?? stringValue(authorRecord?.avatar),
+        },
+        hashtags,
+        stats: {
+            plays: numberValue(statsRecord?.playCount),
+            likes: numberValue(statsRecord?.likeCount) ?? numberValue(statsRecord?.diggCount),
+            comments: numberValue(statsRecord?.commentCount),
+            shares: numberValue(statsRecord?.shareCount),
+            saves: numberValue(statsRecord?.collectCount),
+            reposts: numberValue(statsRecord?.repostCount),
+        },
+        music: {
+            id: stringValue(musicRecord?.id),
+            title: stringValue(musicRecord?.title),
+            author: stringValue(musicRecord?.authorName) ?? stringValue(musicRecord?.author),
+            durationSeconds: numberValue(musicRecord?.duration),
+            url: firstString(musicRecord?.playUrl) ?? stringValue(musicRecord?.playUrl),
+        },
+        media: {
+            videoUrl: firstString(videoRecord?.playAddr) ?? stringValue(videoRecord?.playAddr),
+            downloadUrl: firstString(videoRecord?.downloadAddr) ?? stringValue(videoRecord?.downloadAddr),
+            coverUrl: firstString(videoRecord?.cover) ?? stringValue(videoRecord?.cover) ?? stringValue(item.cover),
+            dynamicCoverUrl: firstString(videoRecord?.dynamicCover) ?? stringValue(videoRecord?.dynamicCover),
+            durationSeconds: numberValue(videoRecord?.duration),
+            width: numberValue(videoRecord?.width),
+            height: numberValue(videoRecord?.height),
+        },
+        raw,
+    };
+}
+function dedupeById(videos) {
+    return [...new Map(videos.map((video) => [video.id, video])).values()];
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asRecord(value) {
+    return isRecord(value) ? value : undefined;
+}
+function stringValue(value) {
+    if (typeof value === "string" && value.trim())
+        return value.trim();
+    if (typeof value === "number" && Number.isFinite(value))
+        return String(value);
+    return undefined;
+}
+function numberValue(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string") {
+        const normalized = value.replace(/,/g, "").trim();
+        const parsed = Number(normalized);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+function booleanValue(value) {
+    if (typeof value === "boolean")
+        return value;
+    if (value === "true")
+        return true;
+    if (value === "false")
+        return false;
+    return undefined;
+}
+function firstString(value) {
+    if (Array.isArray(value))
+        return value.find((entry) => typeof entry === "string" && entry.trim().length > 0);
+    return stringValue(value);
+}
+function arrayOfStrings(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((entry) => {
+        const text = stringValue(entry);
+        return text ? [text] : [];
+    });
+}
+function toIsoTime(value) {
+    const numeric = numberValue(value);
+    if (numeric == null)
+        return undefined;
+    const ms = numeric > 10_000_000_000 ? numeric : numeric * 1000;
+    const date = new Date(ms);
+    return Number.isNaN(date.getTime()) ? undefined : date.toISOString();
+}
+function inferTrailingId(input) {
+    const match = input.match(/(\d{8,})(?:\D*)$/);
+    return match?.[1];
+}
+function inferCollectionId(input) {
+    if (/^\d+$/.test(input.trim()))
+        return input.trim();
+    return input.match(/collection\/[^/\-]*-?(\d+)/i)?.[1] ?? inferTrailingId(input);
+}
+export function normalizeCollectionInput(input, fallbackUsername) {
+    const value = input.trim();
+    let url;
+    if (/^https?:\/\//i.test(value))
+        url = value;
+    else if (/^(www\.)?tiktok\.com\/@/i.test(value))
+        url = `https://${value}`;
+    else if (/^@[^/]+\/collection\//i.test(value))
+        url = `https://www.tiktok.com/${value}`;
+    else if (fallbackUsername && !/^\d+$/.test(value))
+        url = `https://www.tiktok.com/@${fallbackUsername}/collection/${value}`;
+    const collectionId = inferCollectionId(url ?? value);
+    return { collectionId, collectionUrl: url, username: inferUsername(url) ?? fallbackUsername };
+}
+function inferVideoId(input) {
+    if (!input)
+        return undefined;
+    return input.match(/\/video\/(\d+)/)?.[1] ?? inferTrailingId(input);
+}
+function inferUsername(input) {
+    if (!input)
+        return undefined;
+    return input.match(/tiktok\.com\/@([^/?#]+)/)?.[1];
+}
+function looksLikeUrl(input) {
+    return /^https?:\/\//i.test(input);
+}
+export function jsonValueFromUnknown(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+export function jsonObjectFromUnknown(value) {
+    const json = jsonValueFromUnknown(value);
+    return typeof json === "object" && json !== null && !Array.isArray(json) ? json : undefined;
+}

package/dist/transcribe.js

@@ -0,0 +1,162 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { ensureDataDirs, transcriptDir } from "./paths.js";
+import { quoteShell, runProcess, runShell, templateCommand } from "./process.js";
+import { sanitizeFilePart } from "./store.js";
+export async function transcribeVideo(video, options) {
+    ensureDataDirs();
+    if (!options.force && video.transcript?.text) {
+        return { id: video.id, changed: false, transcript: video.transcript };
+    }
+    const input = video.media?.audioPath ?? video.media?.videoPath;
+    if (!input)
+        throw new Error(`${video.id} has no downloaded audio or video. Run tokwise fetch-media --audio first.`);
+    const safeId = sanitizeFilePart(video.id);
+    const outJson = path.join(transcriptDir(), `${safeId}.json`);
+    const outText = path.join(transcriptDir(), `${safeId}.txt`);
+    let raw;
+    let stdout = "";
+    if (options.engine === "whisper") {
+        raw = await runWhisper(input, options);
+    }
+    else if (options.engine === "whisper-cpp") {
+        raw = await runWhisperCpp(input, safeId, options);
+    }
+    else {
+        const result = await runCustom(input, outJson, options);
+        raw = result.raw;
+        stdout = result.stdout;
+    }
+    const parsed = await transcriptFromRaw(raw, stdout, {
+        id: video.id,
+        input,
+        outJson,
+        outText,
+        engine: options.engine,
+        model: options.model,
+        language: options.language,
+    });
+    await fs.writeFile(outJson, `${JSON.stringify(raw ?? parsed, null, 2)}\n`, "utf8");
+    await fs.writeFile(outText, `${parsed.text.trim()}\n`, "utf8");
+    return { id: video.id, changed: true, transcript: parsed };
+}
+async function runWhisper(input, options) {
+    const command = options.command ?? "whisper";
+    const args = [input, "--output_dir", transcriptDir(), "--output_format", "json"];
+    if (options.model)
+        args.push("--model", options.model);
+    if (options.language)
+        args.push("--language", options.language);
+    const result = await runProcess(command, args);
+    if (result.code !== 0)
+        throw new Error(`whisper failed: ${result.stderr || result.stdout}`);
+    const expected = path.join(transcriptDir(), `${path.basename(input, path.extname(input))}.json`);
+    return readJsonIfExists(expected) ?? { stdout: result.stdout };
+}
+async function runWhisperCpp(input, safeId, options) {
+    const command = options.command ?? "whisper-cli";
+    const prefix = path.join(transcriptDir(), safeId);
+    const args = ["-f", input, "-oj", "-of", prefix];
+    if (options.model)
+        args.unshift("-m", options.model);
+    if (options.language)
+        args.push("-l", options.language);
+    const result = await runProcess(command, args);
+    if (result.code !== 0)
+        throw new Error(`whisper.cpp failed: ${result.stderr || result.stdout}`);
+    return readJsonIfExists(`${prefix}.json`) ?? { stdout: result.stdout };
+}
+async function runCustom(input, output, options) {
+    if (!options.command)
+        throw new Error("--command is required for --engine custom.");
+    const command = templateCommand(options.command, {
+        input,
+        output,
+        language: options.language,
+        model: options.model,
+    });
+    const result = await runShell(command);
+    if (result.code !== 0)
+        throw new Error(`custom STT failed: ${result.stderr || result.stdout}`);
+    const raw = (await readJsonIfExists(output)) ?? (await readTextIfExists(output)) ?? { stdout: result.stdout };
+    return { raw, stdout: result.stdout };
+}
+async function transcriptFromRaw(raw, stdout, context) {
+    const record = typeof raw === "object" && raw !== null ? raw : undefined;
+    const text = stringValue(record?.text) ??
+        stringValue(record?.transcript) ??
+        stringValue(record?.stdout) ??
+        (typeof raw === "string" ? raw : undefined) ??
+        stdout;
+    const segments = parseSegments(record?.segments);
+    return {
+        text: text.trim(),
+        language: stringValue(record?.language) ?? context.language,
+        engine: context.engine,
+        model: context.model,
+        sourcePath: context.input,
+        jsonPath: context.outJson,
+        textPath: context.outText,
+        generatedAt: new Date().toISOString(),
+        segments,
+    };
+}
+function parseSegments(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const segments = value.flatMap((segment) => {
+        if (typeof segment !== "object" || segment === null)
+            return [];
+        const record = segment;
+        const text = stringValue(record.text);
+        if (!text)
+            return [];
+        return [
+            {
+                start: numberValue(record.start),
+                end: numberValue(record.end),
+                text,
+            },
+        ];
+    });
+    return segments.length > 0 ? segments : undefined;
+}
+async function readJsonIfExists(filePath) {
+    try {
+        return JSON.parse(await fs.readFile(filePath, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function readTextIfExists(filePath) {
+    try {
+        return fs.readFile(filePath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function stringValue(value) {
+    if (typeof value === "string" && value.trim())
+        return value;
+    return undefined;
+}
+function numberValue(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+export function renderCustomTemplateHelp() {
+    return [
+        "Custom STT command placeholders:",
+        `  {input}    ${quoteShell("/path/to/audio.m4a")}`,
+        `  {output}   ${quoteShell("/path/to/transcript.json")}`,
+        "  {language} requested language",
+        "  {model}    requested model",
+    ].join("\n");
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "tokwise",
+  "version": "0.1.0",
+  "description": "Local-first CLI for syncing, downloading, transcribing, searching, and analyzing saved short-form videos.",
+  "type": "module",
+  "author": "Sebastian Crossa",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sebastiancrossa/tokwise-cli.git"
+  },
+  "homepage": "https://github.com/sebastiancrossa/tokwise-cli#readme",
+  "bugs": {
+    "url": "https://github.com/sebastiancrossa/tokwise-cli/issues"
+  },
+  "bin": {
+    "tokwise": "dist/cli.js",
+    "tw": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/cli.ts",
+    "test": "node --import tsx --test tests/**/*.test.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "keywords": [
+    "tokwise",
+    "short-form-video",
+    "cli",
+    "transcription",
+    "local-first",
+    "knowledge-base",
+    "agent-tools",
+    "search",
+    "bm25",
+    "yt-dlp",
+    "whisper"
+  ],
+  "dependencies": {
+    "@tobyg74/tiktok-api-dl": "^1.3.7",
+    "commander": "^15.0.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3"
+  }
+}