@viralspin/mcp 0.2.0 → 0.2.2

package/dist/tools/color-grade.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colorGradeTool = void 0;
+/**
+ * color_grade — free, instant cinematic LUT looks (ffmpeg, no AI, no cost). The
+ * cheap counterpart to relight_clip: it regrades color/contrast but can't change
+ * the background or add 3D relighting. Great for the A-roll or any clip.
+ */
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const engine_js_1 = require("../engine.js");
+const LOOKS = ["teal-orange", "noir", "warm-golden", "cool-cinematic", "vintage", "vibrant", "moody-blue"];
+function runGrade(args) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(process.platform === "win32" ? "node.exe" : "node", [path_1.default.join(engine_js_1.ENGINE_DIR, "grade.mjs"), ...args], { cwd: engine_js_1.ENGINE_DIR, env: { ...process.env } });
+        let out = "";
+        child.stdout.on("data", (d) => { out += d.toString(); });
+        child.stderr.on("data", (d) => process.stderr.write(d));
+        child.on("error", reject);
+        child.on("close", (code) => {
+            const m = out.match(/RESULT:([\s\S]+)/);
+            if (code === 0 && m)
+                resolve(m[1].trim());
+            else
+                reject(new Error(out.slice(-300) || `grade exited ${code}`));
+        });
+    });
+}
+exports.colorGradeTool = {
+    name: "color_grade",
+    description: "Apply a FREE, instant cinematic color grade / LUT look to a LOCAL video (no AI, no cost) — teal-orange, " +
+        "noir, warm-golden, cool-cinematic, vintage, vibrant, or moody-blue. Great for the A-roll or any clip; it's " +
+        "a toggle-able look (keep the original or the graded file). For true relighting / background change, that's " +
+        "the paid relight_clip instead. Omit `look` to list the available looks.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            video_path: { type: "string", description: "Local path to the video to grade." },
+            look: { type: "string", enum: LOOKS, description: "The look to apply. Omit to list all looks." },
+        },
+        required: ["video_path"],
+    },
+    async execute(args) {
+        if (!(0, engine_js_1.engineAvailable)("grade.mjs")) {
+            return "color_grade needs the local engine (ffmpeg). It's unavailable in this install.";
+        }
+        if (!args.look) {
+            const r = JSON.parse(await runGrade(["--list"]));
+            const lines = r.looks.map((l) => `  • ${l.key} — ${l.label}`);
+            return ["Free cinematic looks (no cost):", ...lines, "", `Apply one: color_grade(video_path: "${args.video_path}", look: "teal-orange").`].join("\n");
+        }
+        let r;
+        try {
+            r = JSON.parse(await runGrade([args.video_path, args.look]));
+        }
+        catch (e) {
+            return `Couldn't grade the video: ${e instanceof Error ? e.message : String(e)}`;
+        }
+        return `Applied the "${r.look}" grade → ${r.out}\nFree + instant (ffmpeg). Swap it in, or try another look.`;
+    },
+};

package/dist/tools/connections.js

@@ -4,15 +4,34 @@ exports.listConnectionsTool = void 0;
 const client_js_1 = require("../client.js");
 exports.listConnectionsTool = {
     name: "list_connections",
-    description: "List your connected social media accounts (TikTok, Instagram, YouTube).",
+    description: "List your connected social media accounts (TikTok, Instagram, YouTube). " +
+        "Returns each account's connection ID — pass the ID to publish_now / schedule_post / send_to_drafts " +
+        "via the account_ids param when you have multiple accounts on the same platform.",
     inputSchema: { type: "object", properties: {}, required: [] },
     async execute(_args) {
+        var _a;
         const connections = await (0, client_js_1.get)("/v1/publish/connections");
         if (!connections.length) {
             return "No platforms connected yet. Visit https://www.viralspin.ai/spin/settings to connect your accounts.";
         }
-        return connections
-            .map((c) => `${c.platform}: ${c.display_name} (${c.username}) — ${c.follower_count.toLocaleString()} followers`)
-            .join("\n");
+        // Group by platform
+        const byPlatform = {};
+        for (const c of connections) {
+            (byPlatform[_a = c.platform] ?? (byPlatform[_a] = [])).push(c);
+        }
+        const lines = [];
+        for (const [platform, accounts] of Object.entries(byPlatform)) {
+            lines.push(`${platform.toUpperCase()}:`);
+            for (const c of accounts) {
+                const label = c.account_label ? ` [${c.account_label}]` : "";
+                const handle = c.username ? ` (@${c.username.replace(/^@/, "")})` : "";
+                const followers = c.follower_count > 0 ? ` — ${c.follower_count.toLocaleString()} followers` : "";
+                lines.push(`  • ${c.display_name}${handle}${label}${followers}`);
+                lines.push(`    id: ${c.id}`);
+            }
+        }
+        lines.push("");
+        lines.push("Tip: when publishing to a specific account, pass its id in the account_ids param.");
+        return lines.join("\n");
     },
 };

package/dist/tools/edit-clip.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editRawClipTool = void 0;
+/**
+ * edit_raw_clip — "edit this" for a RAW local talking-head clip. Transcribes it, cuts the dead
+ * space + filler words, burns captions, and drops RICH on-beat motion-graphics (an LLM plans
+ * varied stat / logo tile / step / quote cards from the transcript) → a finished 9:16 short.
+ *
+ * Runs on the user's machine via the bundled intake engine (mcp/engine/intake.py). Only the
+ * transcript (not the footage) is sent to the cloud graphics planner, so the video stays local.
+ * Falls back to on-device deterministic graphics if the planner isn't reachable.
+ */
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const engine_js_1 = require("../engine.js");
+const client_js_1 = require("../client.js");
+/** Spawn the local Python intake engine, trying the usual interpreter names. */
+function runPy(args) {
+    const bins = process.platform === "win32" ? ["python", "py", "python3"] : ["python3", "python"];
+    return new Promise((resolve, reject) => {
+        const tryBin = (i) => {
+            if (i >= bins.length) {
+                reject(new Error("Python 3 not found on PATH — install it to use edit_raw_clip."));
+                return;
+            }
+            const child = (0, child_process_1.spawn)(bins[i], [path_1.default.join(engine_js_1.ENGINE_DIR, "intake.py"), ...args], { cwd: engine_js_1.ENGINE_DIR, env: { ...process.env } });
+            let out = "", err = "";
+            child.stdout.on("data", (d) => { out += d.toString(); });
+            child.stderr.on("data", (d) => { err += d.toString(); });
+            child.on("error", (e) => { if (e.code === "ENOENT")
+                tryBin(i + 1);
+            else
+                reject(e); });
+            child.on("close", (code) => {
+                if (code === 0)
+                    resolve(out);
+                else
+                    reject(new Error((err || out).slice(-500) || `intake exited ${code}`));
+            });
+        };
+        tryBin(0);
+    });
+}
+exports.editRawClipTool = {
+    name: "edit_raw_clip",
+    description: "EDIT a raw local talking-head video into a finished 9:16 short — the natural tool for \"edit this: " +
+        "<path>\", \"dress this clip\", or \"clean up my talking-head recording\". It transcribes the clip, cuts " +
+        "the dead space and filler words (um/uh/…), burns captions, and drops RICH on-beat motion-graphics — " +
+        "varied stat cards, brand/logo tiles, step/pipeline cards, and quote cards, chosen and filled by an LLM " +
+        "from what's actually said (like a polished explainer, not just captions). Runs on the user's machine; " +
+        "the footage stays local (only the transcript is used to plan graphics). Give it the video_path; returns " +
+        "the finished file path (and a preview URL). For a pure color/LUT look instead, that's color_grade.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            video_path: { type: "string", description: "Local path to the raw talking-head video to edit (e.g. G:/clips/talk.mov)." },
+            captions: { type: "boolean", description: "Burn captions onto the reel (default true)." },
+            graphics: { type: "boolean", description: "Add on-beat motion-graphics (default true)." },
+            sensitivity: { type: "number", description: "Dead-space cut threshold in seconds (default 0.5; lower = tighter, more cuts)." },
+            out_path: { type: "string", description: "Where to write the finished reel (default: next to the input as <name>_edited.mp4)." },
+        },
+        required: ["video_path"],
+    },
+    async execute(args) {
+        if (!(0, engine_js_1.engineAvailable)("intake.py")) {
+            return "edit_raw_clip needs the local editing engine (Python + ffmpeg). It's unavailable in this install.";
+        }
+        const vp = (args.video_path || "").trim().replace(/^["']|["']$/g, "");
+        if (!vp || !fs_1.default.existsSync(vp)) {
+            return `Couldn't find that video: ${vp || "(no path given)"}. Pass a local path, e.g. edit_raw_clip(video_path: "G:/clips/talk.mov").`;
+        }
+        const tmp = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "vs-edit-"));
+        const wordsPath = path_1.default.join(tmp, "words.json");
+        const outPath = args.out_path || vp.replace(/\.[^./\\]+$/, "") + "_edited.mp4";
+        const wantGraphics = args.graphics !== false;
+        try {
+            // 1) transcribe → word timestamps (reused by the cut + captions + planner, so no double work)
+            await runPy(["transcribe", "--clip", vp, "--out", wordsPath]);
+            const words = JSON.parse(fs_1.default.readFileSync(wordsPath, "utf8"));
+            // 2) plan RICH graphics from the transcript (LLM, best-effort). Only the transcript leaves the
+            //    machine. If it fails, the engine falls back to on-device deterministic graphics.
+            const planArgs = [];
+            let plannerNote = "on-device graphics";
+            if (wantGraphics && words.length) {
+                try {
+                    const dur = words[words.length - 1]?.end || 0;
+                    const { graphics } = await (0, client_js_1.pyPost)("/v1/spin/plan-graphics", { words, duration: dur });
+                    if (Array.isArray(graphics) && graphics.length) {
+                        const pp = path_1.default.join(tmp, "plan.json");
+                        fs_1.default.writeFileSync(pp, JSON.stringify(graphics));
+                        planArgs.push("--graphics", pp);
+                        plannerNote = `${graphics.length} LLM-planned graphics`;
+                    }
+                }
+                catch { /* planner unreachable → on-device fallback */ }
+            }
+            // 3) dress: cut dead space + filler → captions → graphics (reusing the transcript)
+            const dressArgs = ["dress", "--clip", vp, "--out", outPath, "--words", wordsPath, "--max-gap", String(args.sensitivity ?? 0.5), ...planArgs];
+            if (args.captions === false)
+                dressArgs.push("--no-captions");
+            if (!wantGraphics)
+                dressArgs.push("--no-graphics");
+            const dressOut = await runPy(dressArgs);
+            const rm = dressOut.match(/REPORT:(\{.*\})/);
+            const report = rm ? JSON.parse(rm[1]) : {};
+            // 4) best-effort upload for a shareable preview URL (local file is the real deliverable)
+            let url = "";
+            try {
+                url = (await (0, client_js_1.uploadFiles)([outPath])).urls[0] || "";
+            }
+            catch { /* local-only is fine */ }
+            const bits = [
+                `Edited **${path_1.default.basename(vp)}** → \`${outPath}\``,
+                `• ${report.original_sec ?? "?"}s → ${report.cut_sec ?? "?"}s (${report.pct_removed ?? 0}% tighter), ${report.n_cuts ?? 0} cuts`,
+                `• ${report.n_graphics ?? 0} on-beat graphics (${plannerNote})${args.captions === false ? "" : " + captions"}`,
+            ];
+            if (url)
+                bits.push(`• Preview: ${url}`);
+            return bits.join("\n");
+        }
+        catch (e) {
+            return `Couldn't edit the clip: ${e instanceof Error ? e.message : String(e)}`;
+        }
+        finally {
+            try {
+                fs_1.default.rmSync(tmp, { recursive: true, force: true });
+            }
+            catch { /* ignore */ }
+        }
+    },
+};

package/dist/tools/engage.js

@@ -5,7 +5,9 @@ const client_js_1 = require("../client.js");
 function describe(k) {
     const scope = k.media_id ? `post ${k.media_id}` : "all posts";
     const platform = k.platform ?? "any platform";
-    const reply = k.reply_to_comment ? ", + comment reply" : ", DM only";
+    const reply = k.reply_to_comment
+        ? (k.comment_reply_text ? `, replies "${k.comment_reply_text}"` : ", + comment reply")
+        : ", DM only";
     const status = k.is_active ? "" : " (paused)";
     return `"${k.keyword}" → ${k.link}  [${platform}, ${scope}, ${k.match_type}${reply}]${status}`;
 }
@@ -31,13 +33,19 @@ exports.setKeywordLinkTool = {
             },
             match_type: {
                 type: "string",
-                enum: ["exact", "contains"],
-                description: "'contains' (default) fires if the comment includes the keyword; 'exact' requires a full match.",
+                enum: ["exact", "contains", "word"],
+                description: "'word' (default, recommended) fires when the keyword appears as a whole word — 'the app.' matches, " +
+                    "'appreciate' does not. 'contains' fires on any substring, which misfires on short keywords. " +
+                    "'exact' requires the comment to be nothing but the keyword.",
             },
             reply_to_comment: {
                 type: "boolean",
                 description: "Also post a public reply to the comment (e.g. 'Check your DMs', wording varies). Defaults to true.",
             },
+            comment_reply_text: {
+                type: "string",
+                description: "Custom wording for that public reply. Omit to rotate through the built-in phrases.",
+            },
         },
         required: ["keyword", "link"],
     },
@@ -47,8 +55,9 @@ exports.setKeywordLinkTool = {
             link: args.link,
             platform: args.platform ?? null,
             media_id: args.media_id ?? null,
-            match_type: args.match_type ?? "contains",
+            match_type: args.match_type ?? "word",
             reply_to_comment: args.reply_to_comment ?? true,
+            comment_reply_text: args.comment_reply_text ?? null,
         });
         return `Saved: ${describe(created)}`;
     },

package/dist/tools/explainer-index.js

@@ -186,6 +186,12 @@ exports.indexExplainerSourcesTool = {
         required: ["sources_folder"],
     },
     async execute(args) {
+        // Credit gate: Twelve Labs indexing makes paid API calls that are not yet
+        // metered to a user's credit balance, so it is OFF by default for public
+        // MCP deployments. Internal/power users can enable it explicitly.
+        if (process.env.EXPLAINER_INDEX_ENABLED !== "true") {
+            return "Twelve Labs explainer indexing is disabled. This feature calls a paid API that is not yet billed to credits, so it is off by default. To enable it for internal use, set EXPLAINER_INDEX_ENABLED=true in the MCP environment.";
+        }
         const apiKey = process.env.TWELVE_LABS_API_KEY;
         if (!apiKey) {
             return "Error: TWELVE_LABS_API_KEY is not set in the MCP environment. Add it to your ~/.claude.json MCP config under env.TWELVE_LABS_API_KEY.";

package/dist/tools/find-moments.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findMomentsTool = void 0;
+/**
+ * find_moments — surface highlight windows inside a long/silent local video so
+ * the agent can build a reel without the user pre-splitting it. Shells out to the
+ * engine's moments.mjs (ffmpeg frame sampling + vision scoring via the configured
+ * model — local Ollama when VIRALSPIN_VLM is set, else cloud Gemini).
+ */
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const engine_js_1 = require("../engine.js");
+function runMoments(args, script = "moments.mjs") {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(process.platform === "win32" ? "node.exe" : "node", [path_1.default.join(engine_js_1.ENGINE_DIR, script), ...args], {
+            cwd: engine_js_1.ENGINE_DIR,
+            env: { ...process.env },
+        });
+        let out = "";
+        child.stdout.on("data", (d) => { out += d.toString(); });
+        child.stderr.on("data", (d) => process.stderr.write(d));
+        child.on("error", reject);
+        child.on("close", (code) => {
+            const m = out.match(/RESULT:([\s\S]+)/);
+            if (code === 0 && m)
+                resolve(m[1].trim());
+            else
+                reject(new Error(out.slice(-400) || `moments engine exited ${code}`));
+        });
+    });
+}
+exports.findMomentsTool = {
+    name: "find_moments",
+    description: "Find the highlight-worthy moments INSIDE a long or silent LOCAL video (e.g. a screen recording or B-roll " +
+        "reel) — no need to split it first. Samples frames and scores them with the configured vision model " +
+        "(free + private local Ollama when local mode is on, else cloud), and returns 0.6–3s windows with " +
+        "descriptions. Pass `query` to bias toward a theme. Set `extract: true` to ALSO cut each highlight into " +
+        "its own small clip LOCALLY — then you upload only those snippets (not the long source). Build a reel from " +
+        "them with create_video_assembly: destination:'hosted' uploads ONLY the snippets + opens the web editor; " +
+        "destination:'local' keeps everything on-device (no upload). Same analysis, two destinations.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            video_path: { type: "string", description: "Local path to the long video to scan." },
+            query: { type: "string", description: "Optional theme to bias toward (e.g. 'surprise reveal', 'on-screen editing')." },
+            threshold: { type: "number", description: "Score cutoff 0..1 for a 'highlight' (default 0.55; lower = more windows)." },
+            extract: { type: "boolean", description: "Also cut each highlight into its own small clip locally (so you upload only the snippets). Default false = just list the windows." },
+            mode: { type: "string", enum: ["highlight", "screen"], description: "'highlight' (default) = VLM-scored striking moments for any footage. 'screen' = SCREEN-RECORDING mode: frame-diff finds where the on-screen ACTION is and returns a focal point (x,y) + suggested punch-in zoom per snippet, so the reel can auto-zoom to exactly where things happen (cursor, typing, output). Use for app/product demos." },
+        },
+        required: ["video_path"],
+    },
+    async execute(args) {
+        if (args.mode === "screen")
+            return runScreenMode(args);
+        if (!(0, engine_js_1.engineAvailable)("moments.mjs")) {
+            return "find_moments needs the local engine (it runs ffmpeg + the vision model). It's unavailable in this install — set VIRALSPIN_ASSEMBLY_DIR, or use the hosted transcript path (get_transcript + keep_windows) for talking/narrated video instead.";
+        }
+        const cli = [args.video_path];
+        if (args.query)
+            cli.push("--query", args.query);
+        if (args.threshold != null)
+            cli.push("--threshold", String(args.threshold));
+        if (args.extract)
+            cli.push("--extract");
+        let json;
+        try {
+            json = JSON.parse(await runMoments(cli));
+        }
+        catch (e) {
+            return `Couldn't scan the video: ${e instanceof Error ? e.message : String(e)}`;
+        }
+        if (!json.windows?.length) {
+            return `Scanned ${json.sampled} frames over ${Math.round(json.duration)}s but found no standout moments — lower the threshold or add a query.`;
+        }
+        const head = `Found ${json.windows.length} highlight window(s) in ${path_1.default.basename(args.video_path)} (${Math.round(json.duration)}s, ${json.sampled} frames sampled, analyzed locally if local mode is on):`;
+        if (json.clips?.length) {
+            const lines = json.clips.map((c, i) => `${i + 1}. ${c.path}  (${c.from_sec.toFixed(1)}–${c.to_sec.toFixed(1)}s)${c.desc ? ` — ${c.desc}` : ""}`);
+            return [
+                head,
+                `Extracted ${json.clips.length} clip(s) → ${json.out_dir}`,
+                ...lines,
+                ``,
+                `Build a reel from these snippets with create_video_assembly:`,
+                `  • destination:"hosted" → uploads ONLY these snippets (not the long source) + opens the web editor.`,
+                `  • destination:"local"  → keeps everything on-device, no upload (fully private).`,
+            ].join("\n");
+        }
+        const lines = json.windows.map((w, i) => `${i + 1}. ${w.from_sec.toFixed(1)}–${w.to_sec.toFixed(1)}s (score ${w.score})${w.desc ? ` — ${w.desc}` : ""}`);
+        return [
+            head,
+            ...lines,
+            ``,
+            `Re-run with extract:true to cut these into clips (then upload only those), or run keep_windows on a hosted project to cut to just these moments.`,
+        ].join("\n");
+    },
+};
+// SCREEN mode — shells to screen-moments.mjs (frame-diff focal + zoom, VLM label).
+// Returns snippets that carry focal_x/focal_y + zoom so the assembly can punch-in to
+// exactly where the on-screen action is. Each screen recording is a B-roll SOURCE;
+// call once per recording and let the story arc stitch the snippets together.
+async function runScreenMode(args) {
+    if (!(0, engine_js_1.engineAvailable)("screen-moments.mjs")) {
+        return "Screen mode needs the local engine (ffmpeg + Python opencv). It's unavailable in this install — set VIRALSPIN_ASSEMBLY_DIR and `pip install opencv-python numpy`.";
+    }
+    const cli = [args.video_path];
+    if (args.threshold != null)
+        cli.push("--threshold", String(args.threshold));
+    if (args.extract)
+        cli.push("--extract");
+    let json;
+    try {
+        json = JSON.parse(await runMoments(cli, "screen-moments.mjs"));
+    }
+    catch (e) {
+        return `Couldn't scan the screen recording: ${e instanceof Error ? e.message : String(e)}`;
+    }
+    if (!json.snippets?.length) {
+        return `Scanned ${json.sampled} frames over ${Math.round(json.duration)}s of ${path_1.default.basename(args.video_path)} but found no clear on-screen action — the recording may be mostly static.`;
+    }
+    const head = `Found ${json.snippets.length} on-screen action moment(s) in ${path_1.default.basename(args.video_path)} (${json.width}×${json.height}, ${Math.round(json.duration)}s). Each carries a focal point + punch-in zoom so the reel can zoom to exactly where the action is:`;
+    const fmt = (s, i) => `${i + 1}. ${s.from_sec.toFixed(1)}–${s.to_sec.toFixed(1)}s — focal (${s.focal_x.toFixed(2)}, ${s.focal_y.toFixed(2)}), zoom ${s.zoom}×${s.label ? ` — “${s.label}”` : ""}`;
+    if (json.clips?.length) {
+        return [
+            head,
+            ...json.snippets.map(fmt),
+            ``,
+            `Extracted ${json.clips.length} snippet clip(s) → ${json.out_dir}`,
+            `These are B-roll candidates: build a screen-demo reel with create_video_assembly (they stitch together with other B-roll; the focal+zoom drive the auto punch-in).`,
+        ].join("\n");
+    }
+    return [
+        head,
+        ...json.snippets.map(fmt),
+        ``,
+        `Re-run with extract:true to cut these into snippet clips, then assemble a screen-demo reel from them (each snippet's focal+zoom drives the punch-in).`,
+    ].join("\n");
+}

package/dist/tools/folder-preview.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewFolderTool = void 0;
+/**
+ * preview_folder — a pre-flight cost gate for assembling a local folder.
+ *
+ * create_video_assembly analyzes every clip (Gemini tags) and charges credits on
+ * create. For a big folder that adds up, so the agent should call this FIRST and
+ * confirm with the user before assembling. Counting is local (reads the disk),
+ * so it's instant and free; the exact credit charge is finalized server-side in
+ * the create response. An optional per-asset rate (env) gives a rough estimate.
+ */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const IMAGE_EXT = new Set([".jpg", ".jpeg", ".png", ".gif", ".webp"]);
+const VIDEO_EXT = new Set([".mp4", ".mov", ".webm", ".m4v"]);
+exports.previewFolderTool = {
+    name: "preview_folder",
+    description: "Before assembling from a LOCAL folder, count its media so you can warn the user about cost. Each clip is " +
+        "analyzed (tagged for matching) and credits are charged when create_video_assembly runs — so for a big " +
+        "folder, call this first and CONFIRM before proceeding. Counting is instant + free; the exact charge is " +
+        "finalized in the create response. Returns video/image counts (+ a rough credit estimate if a per-asset " +
+        "rate is configured via VIRALSPIN_ANALYZE_CREDITS_PER_ASSET).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            folder: { type: "string", description: "Local folder path to inspect." },
+        },
+        required: ["folder"],
+    },
+    async execute(args) {
+        const folder = args.folder;
+        if (!fs_1.default.existsSync(folder))
+            return `Folder not found: ${folder}`;
+        let names;
+        try {
+            const st = fs_1.default.statSync(folder);
+            if (!st.isDirectory())
+                return `${folder} is a file, not a folder.`;
+            names = fs_1.default.readdirSync(folder);
+        }
+        catch (e) {
+            return `Can't read folder: ${e instanceof Error ? e.message : e}`;
+        }
+        let images = 0;
+        let videos = 0;
+        for (const n of names) {
+            const ext = path_1.default.extname(n).toLowerCase();
+            if (VIDEO_EXT.has(ext))
+                videos++;
+            else if (IMAGE_EXT.has(ext))
+                images++;
+        }
+        const total = images + videos;
+        if (!total)
+            return `No images or videos found in ${folder}.`;
+        const rate = Number(process.env.VIRALSPIN_ANALYZE_CREDITS_PER_ASSET || "");
+        const est = Number.isFinite(rate) && rate > 0 ? ` Rough estimate: ~${Math.round(total * rate)} credits (${rate}/clip).` : "";
+        const warnAt = Number(process.env.VIRALSPIN_FOLDER_WARN || "40");
+        const big = total > warnAt;
+        return (`${folder}\n` +
+            `${total} media file(s): ${videos} video(s), ${images} image(s).\n` +
+            `Each is analyzed when you assemble; credits are charged on create_video_assembly and finalized in its response.${est}\n` +
+            (big
+                ? `⚠️ Large folder — CONFIRM with the user before assembling (it will cost credits). Consider a sub-folder or only the best clips.`
+                : `Small enough to assemble directly.`));
+    },
+};