vidgen 0.0.1

package/bin/dev.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node --loader ts-node/esm --no-warnings=ExperimentalWarning "%~dp0\dev" %*

package/bin/dev.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env -S node --loader ts-node/esm --disable-warning=ExperimentalWarning
+
+import {execute} from '@oclif/core'
+
+await execute({development: true, dir: import.meta.url})

package/bin/run.cmd

@@ -0,0 +1,3 @@
+@echo off
+
+node "%~dp0\run" %*

package/bin/run.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import {execute} from '@oclif/core'
+
+await execute({dir: import.meta.url})

package/dist/commands/db/init.d.ts

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class DbInit extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/db/init.js

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+import { initDb } from '../../lib/db.js';
+export default class DbInit extends Command {
+    static description = 'Initialize the Turso database schema (projects and segments tables).';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        this.log('Initializing database...');
+        try {
+            await initDb();
+            this.log('Database initialized successfully.');
+        }
+        catch (error) {
+            this.error(`Failed to initialize database: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+}

package/dist/commands/generate/stt.d.ts

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

package/dist/commands/generate/stt.js

@@ -0,0 +1,73 @@
+import { Command, Flags } from '@oclif/core';
+import { transcribe } from '../../lib/stt/index.js';
+export default class GenerateStt extends Command {
+    static description = 'Generate a Speech-to-Text (STT) transcript from an audio file using Deepgram. Populates the SpeechToText object in a Segment.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --audio https://storage.example.com/seg_001.mp3 --output ./captions/seg_001.json',
+    ];
+    static flags = {
+        audio: Flags.string({
+            char: 'a',
+            description: 'URL or local path to the audio file to transcribe',
+            required: true,
+        }),
+        language: Flags.string({
+            char: 'l',
+            description: 'Target language for transcription (e.g. "en"). Omit for auto-detection.',
+        }),
+        model: Flags.string({
+            char: 'm',
+            default: 'nova-3',
+            description: 'Deepgram model to use',
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'Path to write the transcript JSON output',
+            required: true,
+        }),
+        segmentId: Flags.string({
+            char: 's',
+            description: 'Segment ID to update with the STT result',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(GenerateStt);
+        this.log(`[generate:stt] Transcribing: ${flags.audio} → ${flags.output}`);
+        const result = await transcribe({
+            language: flags.language,
+            model: flags.model,
+            url: flags.audio,
+        });
+        const fs = await import('node:fs/promises');
+        await fs.writeFile(flags.output, JSON.stringify(result, null, 2), 'utf8');
+        this.log(`[generate:stt] Done. Duration: ${result.duration}s`);
+        const sttData = {
+            duration: result.duration,
+            refId: result.id,
+            src: flags.output,
+        };
+        if (flags.segmentId) {
+            try {
+                const { getDb } = await import('../../lib/db.js');
+                const db = getDb();
+                const row = await db.execute({
+                    args: [flags.segmentId],
+                    sql: 'SELECT data FROM segments WHERE id = ?',
+                });
+                if (row.rows.length > 0) {
+                    const segmentData = JSON.parse(row.rows[0].data);
+                    segmentData.speechToText = sttData;
+                    await db.execute({
+                        args: [JSON.stringify(segmentData), flags.segmentId],
+                        sql: 'UPDATE segments SET data = ? WHERE id = ?',
+                    });
+                    this.log(`[generate:stt] Database updated for segment ${flags.segmentId}`);
+                }
+            }
+            catch (error) {
+                this.error(`Failed to update database: ${error instanceof Error ? error.message : error}`);
+            }
+        }
+        this.log(JSON.stringify(sttData));
+    }
+}

package/dist/commands/generate/tts.d.ts

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

package/dist/commands/generate/tts.js

@@ -0,0 +1,30 @@
+import { Command, Flags } from '@oclif/core';
+export default class GenerateTts extends Command {
+    static description = 'Generate a Text-to-Speech (TTS) audio file from a script. Populates the TextToSpeech object in a Segment.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --text "Blockchain is revolutionizing..." --voiceId en-US-1 --output ./audio/seg_001.mp3',
+    ];
+    static flags = {
+        output: Flags.string({
+            char: 'o',
+            description: 'Path or URL to write the generated audio file',
+            required: true,
+        }),
+        text: Flags.string({
+            char: 't',
+            description: 'The script text to convert to speech',
+            required: true,
+        }),
+        voiceId: Flags.string({
+            char: 'v',
+            description: 'Voice ID to use for the TTS provider (e.g. ElevenLabs, OpenAI)',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(GenerateTts);
+        this.log(`[generate:tts] Generating audio with voice "${flags.voiceId}" → ${flags.output}`);
+        // TODO: call TTS provider and write { refId, src, duration } to stdout as JSON
+        // Output shape: TextToSpeech { refId: string, src: string, duration: number }
+    }
+}

package/dist/commands/index/chunk.d.ts

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

package/dist/commands/index/chunk.js

@@ -0,0 +1,55 @@
+import { Command, Flags } from '@oclif/core';
+export default class IndexChunk extends Command {
+    static description = 'Slice a video into fixed-duration chunks and extract keyframes for downstream analysis.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --url ./video.mp4 --duration 5 --output ./chunks',
+    ];
+    static flags = {
+        duration: Flags.integer({
+            char: 'd',
+            default: 5,
+            description: 'Duration in seconds for each chunk',
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'Output directory for chunk files and keyframes',
+            required: true,
+        }),
+        url: Flags.string({
+            char: 'u',
+            description: 'URL or local path to the video file',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(IndexChunk);
+        this.log(`[index:chunk] Chunking video: ${flags.url} into ${flags.duration}s segments → ${flags.output}`);
+        const fs = await import('node:fs/promises');
+        const { exec } = await import('node:child_process');
+        const { promisify } = await import('node:util');
+        const path = await import('node:path');
+        const execAsync = promisify(exec);
+        await fs.mkdir(flags.output, { recursive: true });
+        const outputPattern = path.join(flags.output, 'chunk_%03d.mp4');
+        const cmd = `ffmpeg -i "${flags.url}" -f segment -segment_time ${flags.duration} -reset_timestamps 1 -c copy -map 0 "${outputPattern}"`;
+        try {
+            await execAsync(cmd);
+            const files = await fs.readdir(flags.output);
+            const chunks = files.filter(f => f.startsWith('chunk_') && f.endsWith('.mp4'));
+            for (const chunk of chunks) {
+                const chunkPath = path.join(flags.output, chunk);
+                const framePath = path.join(flags.output, chunk.replace('.mp4', '.jpg'));
+                await execAsync(`ffmpeg -i "${chunkPath}" -ss ${flags.duration / 2} -vframes 1 "${framePath}" -y`);
+            }
+            this.log(`[index:chunk] Done.`);
+            const result = chunks.map(c => ({
+                video: path.join(flags.output, c),
+                frame: path.join(flags.output, c.replace('.mp4', '.jpg'))
+            }));
+            this.log(JSON.stringify(result));
+        }
+        catch (error) {
+            this.error(`FFmpeg failed: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+}

package/dist/commands/index/describe.d.ts

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

package/dist/commands/index/describe.js

@@ -0,0 +1,29 @@
+import { Command, Flags } from '@oclif/core';
+export default class IndexDescribe extends Command {
+    static description = 'Use a Vision AI model to generate a text description of an image or video keyframe.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --image ./chunks/frame_001.jpg --output ./descriptions/frame_001.json',
+    ];
+    static flags = {
+        image: Flags.string({
+            char: 'i',
+            description: 'Path or URL to the image/keyframe to describe',
+            required: true,
+        }),
+        model: Flags.string({
+            char: 'm',
+            default: 'gemini-flash',
+            description: 'Vision model to use for description',
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'Path to write the description JSON output',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(IndexDescribe);
+        this.log(`[index:describe] Describing image: ${flags.image} using ${flags.model} → ${flags.output}`);
+        // TODO: implement Vision AI call and write {description, model, imagePath} to output
+    }
+}

package/dist/commands/index/embed.d.ts

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

package/dist/commands/index/embed.js

@@ -0,0 +1,29 @@
+import { Command, Flags } from '@oclif/core';
+export default class IndexEmbed extends Command {
+    static description = 'Convert a text description into a vector embedding for semantic search.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --text "A bitcoin coin spinning on a blue background" --output ./embeddings/frame_001.json',
+    ];
+    static flags = {
+        model: Flags.string({
+            char: 'm',
+            default: 'text-embedding-3-small',
+            description: 'Embedding model to use',
+        }),
+        output: Flags.string({
+            char: 'o',
+            description: 'Path to write the embedding JSON output',
+            required: true,
+        }),
+        text: Flags.string({
+            char: 't',
+            description: 'The text description to embed',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(IndexEmbed);
+        this.log(`[index:embed] Embedding text with ${flags.model} → ${flags.output}`);
+        // TODO: implement embedding API call and write {text, vector, model} to output
+    }
+}

package/dist/commands/index/save.d.ts

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

package/dist/commands/index/save.js

@@ -0,0 +1,24 @@
+import { Command, Flags } from '@oclif/core';
+export default class IndexSave extends Command {
+    static description = 'Save a video chunk\'s metadata (timecodes, description, embedding) to the RAG database.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --metadata ./chunk_001_meta.json --db postgresql://user:pass@localhost/db',
+    ];
+    static flags = {
+        db: Flags.string({
+            char: 'd',
+            description: 'Database connection string',
+            required: true,
+        }),
+        metadata: Flags.string({
+            char: 'm',
+            description: 'Path to the metadata JSON file containing chunk info, description, and embedding',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(IndexSave);
+        this.log(`[index:save] Saving chunk metadata from ${flags.metadata} → database`);
+        // TODO: parse metadata JSON and upsert into DB (video_chunks table)
+    }
+}

package/dist/commands/project/create.d.ts

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

package/dist/commands/project/create.js

@@ -0,0 +1,63 @@
+import { Command, Flags } from '@oclif/core';
+import { getDb } from '../../lib/db.js';
+import { v4 as uuidv4 } from 'uuid';
+export default class ProjectCreate extends Command {
+    static description = 'Create a new video project in the Turso database.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --title "Crypto Explainers" --aspectRatio 9:16',
+    ];
+    static flags = {
+        aspectRatio: Flags.string({
+            char: 'a',
+            default: '9:16',
+            description: 'Project aspect ratio',
+            options: ['1:1', '16:9', '9:16', '11'],
+            required: true,
+        }),
+        description: Flags.string({
+            char: 'd',
+            description: 'Optional project description',
+        }),
+        title: Flags.string({
+            char: 't',
+            description: 'Project title',
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ProjectCreate);
+        const id = uuidv4();
+        const projectData = {
+            aspectRatio: flags.aspectRatio,
+            caption: {
+                id: 'default',
+                name: 'Default',
+                position: 'bottom',
+                size: 'medium',
+            },
+            visuals: {
+                style: 'cinematic',
+                type: 'narrative-video',
+            },
+            voice: {
+                name: 'Default',
+            },
+            // Initialize with empty arrays as per schema
+            segments: [],
+        };
+        try {
+            await getDb().execute({
+                args: [id, flags.title, flags.description || '', JSON.stringify(projectData)],
+                sql: 'INSERT INTO projects (id, title, description, data) VALUES (?, ?, ?, ?)',
+            });
+            this.log(`Project created successfully!`);
+            this.log(`ID: ${id}`);
+            this.log(`Title: ${flags.title}`);
+            // Output JSON for agent chaining
+            this.log(JSON.stringify({ id, title: flags.title }));
+        }
+        catch (error) {
+            this.error(`Failed to create project: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class ProjectDelete 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/project/delete.js

@@ -0,0 +1,31 @@
+import { Args, Command } from '@oclif/core';
+import { getDb } from '../../lib/db.js';
+export default class ProjectDelete extends Command {
+    static args = {
+        id: Args.string({ description: 'Project ID to delete', required: true }),
+    };
+    static description = 'Delete a project and all its associated segments from the Turso database.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> <project-id>',
+    ];
+    async run() {
+        const { args } = await this.parse(ProjectDelete);
+        try {
+            // libSQL batch for atomic delete (though CASCADE should handle it if set up)
+            await getDb().batch([
+                {
+                    args: [args.id],
+                    sql: 'DELETE FROM segments WHERE projectId = ?',
+                },
+                {
+                    args: [args.id],
+                    sql: 'DELETE FROM projects WHERE id = ?',
+                },
+            ], "write");
+            this.log(`Project ${args.id} and its segments have been deleted.`);
+        }
+        catch (error) {
+            this.error(`Failed to delete project: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+}

package/dist/commands/project/get.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class ProjectGet 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/project/get.js

@@ -0,0 +1,39 @@
+import { Args, Command } from '@oclif/core';
+import { getDb } from '../../lib/db.js';
+export default class ProjectGet extends Command {
+    static args = {
+        id: Args.string({ description: 'Project ID to retrieve', required: true }),
+    };
+    static description = 'Retrieve a full project schema including its segments from the Turso database.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> <project-id>',
+    ];
+    async run() {
+        const { args } = await this.parse(ProjectGet);
+        try {
+            const projectRs = await getDb().execute({
+                args: [args.id],
+                sql: 'SELECT * FROM projects WHERE id = ?',
+            });
+            if (projectRs.rows.length === 0) {
+                this.error(`Project with ID ${args.id} not found.`);
+            }
+            const project = projectRs.rows[0];
+            const segmentsRs = await getDb().execute({
+                args: [args.id],
+                sql: 'SELECT * FROM segments WHERE projectId = ? ORDER BY orderIndex ASC',
+            });
+            const schema = {
+                ...JSON.parse(project.data),
+                description: project.description,
+                id: project.id,
+                segments: segmentsRs.rows.map((row) => JSON.parse(row.data)),
+                title: project.title,
+            };
+            this.log(JSON.stringify(schema, null, 2));
+        }
+        catch (error) {
+            this.error(`Failed to get project: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+}

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

@@ -0,0 +1,6 @@
+import { Command } from '@oclif/core';
+export default class ProjectList extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}

package/dist/commands/project/list.js

@@ -0,0 +1,26 @@
+import { Command } from '@oclif/core';
+import { getDb } from '../../lib/db.js';
+export default class ProjectList extends Command {
+    static description = 'List all video projects stored in the Turso database.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    async run() {
+        try {
+            const rs = await getDb().execute('SELECT id, title, description, createdAt FROM projects ORDER BY createdAt DESC');
+            if (rs.rows.length === 0) {
+                this.log('No projects found.');
+                return;
+            }
+            this.log('Listing projects:');
+            for (const row of rs.rows) {
+                this.log(`- ${row.title} (${row.id}) - Created: ${row.createdAt}`);
+            }
+            // Output JSON for agent
+            this.log(JSON.stringify(rs.rows));
+        }
+        catch (error) {
+            this.error(`Failed to list projects: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+}

package/dist/commands/project/validate.d.ts

@@ -0,0 +1,10 @@
+import { Command } from '@oclif/core';
+export default class ProjectValidate extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        schema: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        strict: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/project/validate.js

@@ -0,0 +1,29 @@
+import { Command, Flags } from '@oclif/core';
+import { getDb } from '../../lib/db.js';
+export default class ProjectValidate extends Command {
+    static description = 'Validate a Schema JSON file against the TypeScript Schema interface structure before saving to a database.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> --schema ./schema.json',
+        '<%= config.bin %> <%= command.id %> --schema ./schema.json --strict',
+    ];
+    static flags = {
+        schema: Flags.string({
+            char: 's',
+            description: 'Path to the Schema JSON file to validate',
+            required: true,
+        }),
+        strict: Flags.boolean({
+            default: false,
+            description: 'Fail on missing optional fields in addition to required field validation',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(ProjectValidate);
+        this.log(`[project:validate] Validating schema: ${flags.schema}${flags.strict ? ' (strict mode)' : ''}`);
+        try {
+            const rs = await getDb().execute('SELECT 1');
+            this.log('Database connection verified as well.');
+        }
+        catch { }
+    }
+}

package/dist/commands/search/asset.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+export default class SearchAsset extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        db: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
+        query: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}