vidgen 0.0.1

package/dist/commands/search/asset.js

@@ -0,0 +1,35 @@
+import { Command, Flags } from '@oclif/core';
+export default class SearchAsset extends Command {
+    static description = 'Semantically search the video RAG database for the best matching clip for a given query. Returns matching VisualBroll / Clip metadata.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --query "bitcoin coin spinning on blue background" --db postgresql://user:pass@localhost/db --limit 3',
+    ];
+    static flags = {
+        db: Flags.string({
+            char: 'd',
+            description: 'Database connection string',
+            required: true,
+        }),
+        limit: Flags.integer({
+            char: 'l',
+            default: 1,
+            description: 'Maximum number of results to return',
+        }),
+        query: Flags.string({
+            char: 'q',
+            description: 'The natural language search query (e.g. comes from a Segment\'s searchQuery field)',
+            required: true,
+        }),
+        type: Flags.string({
+            char: 't',
+            description: 'Filter results by asset type',
+            options: ['video', 'image'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SearchAsset);
+        this.log(`[search:asset] Searching for "${flags.query}" (limit: ${flags.limit}) in database`);
+        // TODO: embed query, run vector similarity search, return top results as JSON
+        // Output shape: Array of VisualBroll { url, duration, type, time, ... }
+    }
+}

package/dist/commands/segment/add.d.ts

@@ -0,0 +1,11 @@
+import { Command } from '@oclif/core';
+export default class SegmentAdd extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        data: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        order: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        projectId: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/segment/add.js

@@ -0,0 +1,49 @@
+import { Command, Flags } from '@oclif/core';
+import { getDb } from '../../lib/db.js';
+import { v4 as uuidv4 } from 'uuid';
+export default class SegmentAdd extends Command {
+    static description = 'Add a new segment to a project. Data should be a JSON string matching the Segment interface.';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> --projectId <project-id> --data '{"title":"Scene 1","text":"Hello"}' --order 0`,
+    ];
+    static flags = {
+        data: Flags.string({
+            char: 'd',
+            description: 'JSON string of the segment data',
+            required: true,
+        }),
+        order: Flags.integer({
+            char: 'n',
+            default: 0,
+            description: 'Order index for the segment',
+        }),
+        projectId: Flags.string({
+            char: 'p',
+            description: 'Project ID to attach the segment to',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(SegmentAdd);
+        const id = uuidv4();
+        try {
+            // Validate JSON data can be parsed
+            const segmentObject = JSON.parse(flags.data);
+            // Ensure ID is set in the data too if not provided
+            if (!segmentObject.id) {
+                segmentObject.id = id;
+            }
+            await getDb().execute({
+                args: [segmentObject.id, flags.projectId, flags.order, JSON.stringify(segmentObject)],
+                sql: 'INSERT INTO segments (id, projectId, orderIndex, data) VALUES (?, ?, ?, ?)',
+            });
+            this.log(`Segment added successfully!`);
+            this.log(`ID: ${segmentObject.id}`);
+            // Output JSON for agent
+            this.log(JSON.stringify({ id: segmentObject.id, projectId: flags.projectId }));
+        }
+        catch (error) {
+            this.error(`Failed to add segment: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+}

package/dist/commands/segment/delete.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class SegmentDelete extends Command {
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/segment/delete.js

@@ -0,0 +1,29 @@
+import { Args, Command } from '@oclif/core';
+import { getDb } from '../../lib/db.js';
+export default class SegmentDelete extends Command {
+    static args = {
+        id: Args.string({ description: 'Segment ID to delete', required: true }),
+    };
+    static description = 'Delete a specific segment from the Turso database.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> <segment-id>',
+    ];
+    async run() {
+        const { args } = await this.parse(SegmentDelete);
+        try {
+            const rs = await getDb().execute({
+                args: [args.id],
+                sql: 'DELETE FROM segments WHERE id = ?',
+            });
+            if (rs.rowsAffected === 0) {
+                this.log(`Segment ${args.id} not found or already deleted.`);
+            }
+            else {
+                this.log(`Segment ${args.id} deleted successfully.`);
+            }
+        }
+        catch (error) {
+            this.error(`Failed to delete segment: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+}

package/dist/commands/segment/list.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class SegmentList extends Command {
+    static args: {
+        projectId: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/segment/list.js

@@ -0,0 +1,33 @@
+import { Args, Command } from '@oclif/core';
+import { getDb } from '../../lib/db.js';
+export default class SegmentList extends Command {
+    static args = {
+        projectId: Args.string({ description: 'Project ID to list segments for', required: true }),
+    };
+    static description = 'List all segments associated with a specific project.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> <project-id>',
+    ];
+    async run() {
+        const { args } = await this.parse(SegmentList);
+        try {
+            const rs = await getDb().execute({
+                args: [args.projectId],
+                sql: 'SELECT id, orderIndex, data FROM segments WHERE projectId = ? ORDER BY orderIndex ASC',
+            });
+            if (rs.rows.length === 0) {
+                this.log('No segments found for this project.');
+                return;
+            }
+            this.log(`Listing segments for project ${args.projectId}:`);
+            for (const row of rs.rows) {
+                const data = JSON.parse(row.data);
+                this.log(`[${row.orderIndex}] ${data.title || 'Untitled'} (${row.id})`);
+            }
+            this.log(JSON.stringify(rs.rows.map((r) => ({ id: r.id, orderIndex: r.orderIndex, ...JSON.parse(r.data) }))));
+        }
+        catch (error) {
+            this.error(`Failed to list segments: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+}

package/dist/commands/segment/update.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class SegmentUpdate extends Command {
+    static args: {
+        id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        data: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        order: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/segment/update.js

@@ -0,0 +1,50 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { getDb } from '../../lib/db.js';
+export default class SegmentUpdate extends Command {
+    static args = {
+        id: Args.string({ description: 'Segment ID to update', required: true }),
+    };
+    static description = 'Update an existing segment\'s data.';
+    static examples = [
+        `<%= config.bin %> <%= command.id %> <segment-id> --data '{"title":"New Title"}'`,
+    ];
+    static flags = {
+        data: Flags.string({
+            char: 'd',
+            description: 'JSON string of the segment data to merge/update',
+            required: true,
+        }),
+        order: Flags.integer({
+            char: 'n',
+            description: 'New order index for the segment',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(SegmentUpdate);
+        try {
+            // Get existing data
+            const rs = await getDb().execute({
+                args: [args.id],
+                sql: 'SELECT data, orderIndex FROM segments WHERE id = ?',
+            });
+            if (rs.rows.length === 0) {
+                this.error(`Segment with ID ${args.id} not found.`);
+            }
+            const existingData = JSON.parse(rs.rows[0].data);
+            const updateData = JSON.parse(flags.data);
+            const newData = {
+                ...existingData,
+                ...updateData,
+            };
+            const orderIndex = flags.order !== undefined ? flags.order : rs.rows[0].orderIndex;
+            await getDb().execute({
+                args: [orderIndex, JSON.stringify(newData), args.id],
+                sql: 'UPDATE segments SET orderIndex = ?, data = ? WHERE id = ?',
+            });
+            this.log(`Segment ${args.id} updated successfully.`);
+        }
+        catch (error) {
+            this.error(`Failed to update segment: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+}

package/dist/commands/video/caption.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class VideoSubtitle extends Command {
+    static description: string;
+    static flags: {
+        burnIn: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        transcript: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        video: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    private formatTime;
+    run(): Promise<void>;
+}

package/dist/commands/video/caption.js

@@ -0,0 +1,43 @@
+import { Command, Flags } from '@oclif/core';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import * as fs from 'node:fs/promises';
+const execAsync = promisify(exec);
+export default class VideoSubtitle extends Command {
+    static description = 'Generate SRT captions from a JSON transcript and optionally embed them into a video.';
+    static flags = {
+        burnIn: Flags.boolean({ char: 'b' }),
+        output: Flags.string({ char: 'o', required: true }),
+        transcript: Flags.string({ char: 't', required: true }),
+        video: Flags.string({ char: 'v' }),
+    };
+    formatTime(seconds) {
+        const date = new Date(seconds * 1000);
+        return date.toISOString().substr(11, 12).replace('.', ',');
+    }
+    async run() {
+        const { flags } = await this.parse(VideoSubtitle);
+        const transcript = JSON.parse(await fs.readFile(flags.transcript, 'utf8'));
+        const words = transcript.results?.channels?.[0]?.alternatives?.[0]?.words || [];
+        let srtContent = '';
+        let group = [];
+        let index = 1;
+        for (let i = 0; i < words.length; i++) {
+            group.push(words[i]);
+            if (group.length >= 7 || i === words.length - 1) {
+                srtContent += `${index}\n${this.formatTime(group[0].start)} --> ${this.formatTime(group[group.length - 1].end)}\n${group.map(w => w.punctuated_word || w.word).join(' ')}\n\n`;
+                index++;
+                group = [];
+            }
+        }
+        const srtPath = flags.video ? `${flags.transcript}.srt` : flags.output;
+        await fs.writeFile(srtPath, srtContent);
+        if (flags.video) {
+            let cmd = flags.burnIn
+                ? `ffmpeg -i "${flags.video}" -vf "subtitles='${srtPath.replace(/:/g, '\\:')}'" "${flags.output}" -y`
+                : `ffmpeg -i "${flags.video}" -i "${srtPath}" -c copy -c:s mov_text "${flags.output}" -y`;
+            await execAsync(cmd);
+        }
+        this.log(JSON.stringify({ path: flags.video ? flags.output : srtPath }));
+    }
+}

package/dist/commands/video/trim.d.ts

@@ -0,0 +1,13 @@
+import { Command } from '@oclif/core';
+export default class VideoTrim extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        duration: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        end: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        input: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        start: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/video/trim.js

@@ -0,0 +1,52 @@
+import { Command, Flags } from '@oclif/core';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
+export default class VideoTrim extends Command {
+    static description = 'Precisely trim a video file using start and end timestamps.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --input input.mp4 --start 00:00:10 --end 00:00:20 --output trimmed.mp4',
+    ];
+    static flags = {
+        duration: Flags.string({
+            char: 'd',
+            description: 'Duration to trim',
+        }),
+        end: Flags.string({
+            char: 'e',
+            description: 'End timestamp',
+        }),
+        input: Flags.string({
+            char: 'i',
+            description: 'Input video file path',
+            required: true,
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'Output video file path',
+            required: true,
+        }),
+        start: Flags.string({
+            char: 's',
+            description: 'Start timestamp',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(VideoTrim);
+        let cmd = `ffmpeg -i "${flags.input}" -ss ${flags.start}`;
+        if (flags.end)
+            cmd += ` -to ${flags.end}`;
+        else if (flags.duration)
+            cmd += ` -t ${flags.duration}`;
+        cmd += ` -c copy "${flags.output}" -y`;
+        try {
+            await execAsync(cmd);
+            this.log(`[video:trim] Done.`);
+            this.log(JSON.stringify({ path: flags.output }));
+        }
+        catch (error) {
+            this.error(`FFmpeg failed: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/lib/db.d.ts

@@ -0,0 +1,7 @@
+import { type Client } from '@libsql/client';
+declare function getDb(): Client;
+/**
+ * Initialize the database tables if they don't exist.
+ */
+export declare function initDb(): Promise<void>;
+export { getDb };

package/dist/lib/db.js

@@ -0,0 +1,39 @@
+import { createClient } from '@libsql/client';
+let internalDb = null;
+function getDb() {
+    if (internalDb)
+        return internalDb;
+    const url = process.env.TURSO_DATABASE_URL;
+    const authToken = process.env.TURSO_AUTH_TOKEN;
+    if (!url || !authToken) {
+        throw new Error('TURSO_DATABASE_URL and TURSO_AUTH_TOKEN must be set');
+    }
+    internalDb = createClient({
+        url,
+        authToken,
+    });
+    return internalDb;
+}
+/**
+ * Initialize the database tables if they don't exist.
+ */
+export async function initDb() {
+    const db = getDb();
+    await db.batch([
+        `CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      description TEXT,
+      data TEXT, -- JSON blob
+      createdAt DATETIME DEFAULT CURRENT_TIMESTAMP
+    );`,
+        `CREATE TABLE IF NOT EXISTS segments (
+      id TEXT PRIMARY KEY,
+      projectId TEXT NOT NULL,
+      orderIndex INTEGER NOT NULL,
+      data TEXT, -- JSON blob
+      FOREIGN KEY (projectId) REFERENCES projects(id) ON DELETE CASCADE
+    );`,
+    ], "write");
+}
+export { getDb };

package/dist/lib/stt/deepgram-to-combo.d.ts

@@ -0,0 +1,2 @@
+import { TranscriptObject } from './types.js';
+export declare function deepgramToCombo(deepgramResult: any): Promise<Partial<TranscriptObject>>;

package/dist/lib/stt/deepgram-to-combo.js

@@ -0,0 +1,49 @@
+import { detectLanguage } from './detect-language.js';
+const getWords = (deepgramResult) => {
+    const words = deepgramResult.results.channels[0].alternatives[0].words.map((w) => {
+        return {
+            word: w.punctuated_word,
+            start: w.start,
+            end: w.end,
+            confidence: w.confidence,
+        };
+    });
+    return words;
+};
+const getParagraphs = (deepgramResult) => {
+    const paragraphs = deepgramResult.results.channels[0].alternatives[0].paragraphs.paragraphs
+        .map((p) => {
+        return {
+            sentences: p.sentences.map((s) => {
+                return {
+                    text: s.text,
+                    start: s.start,
+                    end: s.end,
+                };
+            }),
+            numWords: p.num_words,
+            start: p.start,
+            end: p.end,
+        };
+    })
+        .filter((p) => p.sentences.length > 0);
+    return paragraphs;
+};
+export async function deepgramToCombo(deepgramResult) {
+    const text = deepgramResult.results.channels[0].alternatives[0].transcript;
+    const language = await detectLanguage(text);
+    const words = getWords(deepgramResult);
+    const duration = deepgramResult.metadata.duration;
+    const paragraphs = getParagraphs(deepgramResult);
+    return {
+        duration,
+        results: {
+            main: {
+                language,
+                paragraphs,
+                text,
+                words,
+            },
+        },
+    };
+}

package/dist/lib/stt/deepgram.d.ts

@@ -0,0 +1,18 @@
+import { TranscriptObject } from './types.js';
+export declare class SttService {
+    private apiKey;
+    private params;
+    private url;
+    constructor(url: string, apiKey: string, model: string);
+    transcribe(audioUrl: string): Promise<{
+        transcript: Partial<TranscriptObject>;
+        duration: number;
+    }>;
+    transcribeV2(audioUrl: string): Promise<{
+        success: boolean;
+        data: {
+            transcript: Partial<TranscriptObject>;
+            duration: number;
+        };
+    }>;
+}

package/dist/lib/stt/deepgram.js

@@ -0,0 +1,71 @@
+import { deepgramToCombo } from './deepgram-to-combo.js';
+export class SttService {
+    apiKey;
+    params;
+    url;
+    constructor(url, apiKey, model) {
+        this.url = url;
+        this.apiKey = apiKey;
+        this.params = new URLSearchParams({
+            model,
+            smart_format: 'true',
+            filler_words: 'false',
+            punctuate: 'true',
+            detect_language: 'true',
+        }).toString();
+    }
+    async transcribe(audioUrl) {
+        try {
+            const response = await fetch(`${this.url}/listen?${this.params}`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Token ${this.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ url: audioUrl }),
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                console.error(data);
+                throw new Error(`Transcription failed - ${response.status}`);
+            }
+            const caption_combo = await deepgramToCombo(data);
+            return { transcript: caption_combo, duration: data.metadata.duration };
+        }
+        catch (err) {
+            console.error(err);
+            throw new Error('An unknown error occurred.');
+        }
+    }
+    async transcribeV2(audioUrl) {
+        try {
+            const response = await fetch(`${this.url}/listen?${this.params}`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Token ${this.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ url: audioUrl }),
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                console.error(data);
+                return { success: false, data: { transcript: {}, duration: 0 } };
+            }
+            const caption_combo = await deepgramToCombo(data);
+            const durationNum = typeof data.metadata.duration === 'number'
+                ? data.metadata.duration
+                : parseFloat(data.metadata.duration);
+            if (isNaN(durationNum))
+                throw new Error(`Invalid duration for ${audioUrl}`);
+            return {
+                success: true,
+                data: { transcript: caption_combo, duration: durationNum },
+            };
+        }
+        catch (err) {
+            console.error(err);
+            return { success: false, data: { transcript: {}, duration: 0 } };
+        }
+    }
+}

package/dist/lib/stt/detect-language.d.ts

@@ -0,0 +1,2 @@
+export declare function detectLanguage(text: string): Promise<import("./types.js").LanguageDetectionResultsEntry>;
+export declare function languageCodeToName(languageCode: string): string;

package/dist/lib/stt/detect-language.js

@@ -0,0 +1,31 @@
+import { detectAll } from 'tinyld';
+export async function detectLanguage(text) {
+    const tinyldResults = detectAll(text);
+    const results = tinyldResults.map((result) => ({
+        language: result.lang,
+        languageName: languageCodeToName(result.lang),
+        confidence: result.accuracy,
+    }));
+    const [mainLanguage] = results;
+    if (!mainLanguage) {
+        return {
+            language: 'en',
+            languageName: 'English',
+            confidence: 1,
+        };
+    }
+    if (mainLanguage.language === 'und') {
+        mainLanguage.language = 'en';
+        mainLanguage.languageName = 'English';
+    }
+    return mainLanguage;
+}
+export function languageCodeToName(languageCode) {
+    const languageNames = new Intl.DisplayNames(['en'], { type: 'language' });
+    let translatedLanguageName;
+    try {
+        translatedLanguageName = languageNames.of(languageCode);
+    }
+    catch (e) { }
+    return translatedLanguageName || 'Unknown';
+}

package/dist/lib/stt/index.d.ts

@@ -0,0 +1,50 @@
+import type { TranscriptObject } from './types.js';
+export interface TranscribeOptions {
+    /**
+     * Audio URL to transcribe
+     */
+    url: string;
+    /**
+     * API key for Deepgram (optional, defaults to env variable)
+     */
+    apiKey?: string;
+    /**
+     * Target language for transcription (optional)
+     * If not provided, will auto-detect
+     */
+    language?: string;
+    /**
+     * Deepgram model to use (optional, defaults to "nova-3")
+     */
+    model?: string;
+    /**
+     * Whether to enable smart formatting (optional, defaults to true)
+     */
+    smartFormat?: boolean;
+    /**
+     * Whether to include paragraphs in the result (optional, defaults to true)
+     */
+    paragraphs?: boolean;
+    /**
+     * Whether to include word-level timestamps (optional, defaults to true)
+     */
+    words?: boolean;
+}
+/**
+ * Transcribe audio from a URL using Deepgram
+ *
+ * @param options - Transcription options
+ * @returns Parsed transcription result in Combo format
+ *
+ * @example
+ * ```typescript
+ * const result = await transcribe({
+ *   url: "https://example.com/audio.mp3",
+ *   language: "en"
+ * });
+ * ```
+ */
+export declare function transcribe(options: TranscribeOptions): Promise<Partial<TranscriptObject>>;
+export * from './types.js';
+export { deepgramToCombo } from './deepgram-to-combo.js';
+export { detectLanguage } from './detect-language.js';