@tavus/cvi-ui 0.0.1-beta.1

package/dist/types/cli/add.d.ts

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { z } from 'zod';
+import { Command } from 'commander';
+export declare const addOptionsSchema: z.ZodObject<{
+    components: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    overwrite: z.ZodBoolean;
+    cwd: z.ZodString;
+    silent: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    cwd: string;
+    silent: boolean;
+    overwrite: boolean;
+    components?: string[] | undefined;
+}, {
+    cwd: string;
+    silent: boolean;
+    overwrite: boolean;
+    components?: string[] | undefined;
+}>;
+export declare const add: Command;

package/dist/types/cli/info.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const info: Command;

package/dist/types/cli/init.d.ts

@@ -0,0 +1,23 @@
+import { Command } from 'commander';
+import { z } from 'zod';
+export declare const initOptionsSchema: z.ZodObject<{
+    cwd: z.ZodString;
+    silent: z.ZodBoolean;
+    components: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    cwd: string;
+    silent: boolean;
+    components?: string[] | undefined;
+}, {
+    cwd: string;
+    silent: boolean;
+    components?: string[] | undefined;
+}>;
+export declare const init: Command;
+export declare function runInit(options: z.infer<typeof initOptionsSchema>): Promise<{
+    tsx: boolean;
+    resolvedPaths: {
+        components: string;
+        cwd: string;
+    };
+}>;

package/dist/types/components/highlighter.d.ts

@@ -0,0 +1,6 @@
+export declare const highlighter: {
+    error: typeof import("kleur/colors").print;
+    warn: typeof import("kleur/colors").print;
+    info: typeof import("kleur/colors").print;
+    success: typeof import("kleur/colors").print;
+};

package/dist/types/components/logger.d.ts

@@ -0,0 +1,8 @@
+export declare const logger: {
+    error(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    success(...args: unknown[]): void;
+    log(...args: unknown[]): void;
+    break(): void;
+};

package/dist/types/components/spinner.d.ts

@@ -0,0 +1,4 @@
+import { type Options } from "ora";
+export declare function spinner(text: Options["text"], options?: {
+    silent?: boolean;
+}): import("ora").Ora;

package/dist/types/constants/components.d.ts

@@ -0,0 +1,59 @@
+export type ComponentType = 'component' | 'hook' | 'block';
+export declare const COMPONENTS: {
+    'replica-video': {
+        name: string;
+        path: string;
+        type: ComponentType;
+        componentsDependencies: never[];
+        dependency: never[];
+    };
+    'local-video': {
+        name: string;
+        path: string;
+        type: ComponentType;
+        componentsDependencies: never[];
+        dependency: never[];
+    };
+    'cvi-provider': {
+        name: string;
+        path: string;
+        type: ComponentType;
+        componentsDependencies: never[];
+        dependency: string[];
+    };
+    conversation: {
+        name: string;
+        path: string;
+        type: ComponentType;
+        componentsDependencies: never[];
+        dependency: never[];
+    };
+    'hair-check': {
+        name: string;
+        path: string;
+        type: ComponentType;
+        componentsDependencies: never[];
+        dependency: never[];
+    };
+    controls: {
+        name: string;
+        path: string;
+        type: ComponentType;
+        componentsDependencies: never[];
+        dependency: never[];
+    };
+    'cvi-hooks': {
+        name: string;
+        path: string;
+        type: ComponentType;
+        componentsDependencies: never[];
+        dependency: never[];
+    };
+    'cvi-events-hooks': {
+        name: string;
+        path: string;
+        type: ComponentType;
+        componentsDependencies: never[];
+        dependency: never[];
+    };
+};

package/dist/types/constants/config.d.ts

@@ -0,0 +1,5 @@
+export declare const CONFIG: {
+    tsx: boolean;
+};
+export declare const CONFIG_NAME = "cvi-components.json";
+export declare const DEFAULT_DEPENDENCIES: string[];

package/dist/types/constants/errors.d.ts

@@ -0,0 +1,5 @@
+export declare const MISSING_DIR_OR_EMPTY_PROJECT = "1";
+export declare const EXISTING_CONFIG = "2";
+export declare const MISSING_CONFIG = "3";
+export declare const FAILED_CONFIG_READ = "4";
+export declare const UNSUPPORTED_FRAMEWORK = "7";

package/dist/types/constants/frameworks.d.ts

@@ -0,0 +1,39 @@
+export declare const FRAMEWORKS: {
+    readonly 'next-app': {
+        readonly name: "next-app";
+        readonly label: "Next.js";
+    };
+    readonly 'next-pages': {
+        readonly name: "next-pages";
+        readonly label: "Next.js";
+    };
+    readonly remix: {
+        readonly name: "remix";
+        readonly label: "Remix";
+    };
+    readonly 'react-router': {
+        readonly name: "react-router";
+        readonly label: "React Router";
+    };
+    readonly vite: {
+        readonly name: "vite";
+        readonly label: "Vite";
+    };
+    readonly astro: {
+        readonly name: "astro";
+        readonly label: "Astro";
+    };
+    readonly 'tanstack-start': {
+        readonly name: "tanstack-start";
+        readonly label: "TanStack Start";
+    };
+    readonly gatsby: {
+        readonly name: "gatsby";
+        readonly label: "Gatsby";
+    };
+    readonly manual: {
+        readonly name: "manual";
+        readonly label: "Manual";
+    };
+};
+export type Framework = (typeof FRAMEWORKS)[keyof typeof FRAMEWORKS];

package/dist/types/index.d.ts

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

package/dist/types/preflights/preflight-add.d.ts

@@ -0,0 +1,15 @@
+import { addOptionsSchema } from '@/src/cli/add';
+import { z } from 'zod';
+export declare function preFlightAdd(options: z.infer<typeof addOptionsSchema>): Promise<{
+    errors: Record<string, boolean>;
+    config: null;
+} | {
+    errors: Record<string, boolean>;
+    config: {
+        tsx: boolean;
+        resolvedPaths: {
+            components: string;
+            cwd: string;
+        };
+    };
+}>;

package/dist/types/preflights/preflight-init.d.ts

@@ -0,0 +1,9 @@
+import { initOptionsSchema } from '@/src/cli/init';
+import { z } from 'zod';
+export declare function preFlightInit(options: z.infer<typeof initOptionsSchema>): Promise<{
+    errors: Record<string, boolean>;
+    projectInfo: null;
+} | {
+    errors: Record<string, boolean>;
+    projectInfo: import("@/src/utils/get-project-info").ProjectInfo;
+}>;

package/dist/types/utils/add-components.d.ts

@@ -0,0 +1,5 @@
+import { type Config } from '@/src/utils/get-config';
+export declare function addComponents(components: string[], config: Config, options: {
+    overwrite?: boolean;
+    silent?: boolean;
+}): Promise<void>;

package/dist/types/utils/get-config.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export declare const rawConfigSchema: z.ZodObject<{
+    tsx: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    tsx: boolean;
+}, {
+    tsx?: boolean | undefined;
+}>;
+export type RawConfig = z.infer<typeof rawConfigSchema>;
+export declare const configSchema: z.ZodObject<z.objectUtil.extendShape<{
+    tsx: z.ZodDefault<z.ZodBoolean>;
+}, {
+    resolvedPaths: z.ZodObject<{
+        cwd: z.ZodString;
+        components: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        components: string;
+        cwd: string;
+    }, {
+        components: string;
+        cwd: string;
+    }>;
+}>, "strict", z.ZodTypeAny, {
+    tsx: boolean;
+    resolvedPaths: {
+        components: string;
+        cwd: string;
+    };
+}, {
+    resolvedPaths: {
+        components: string;
+        cwd: string;
+    };
+    tsx?: boolean | undefined;
+}>;
+export type Config = z.infer<typeof configSchema>;
+export declare function getConfig(cwd: string): Promise<{
+    tsx: boolean;
+    resolvedPaths: {
+        components: string;
+        cwd: string;
+    };
+} | null>;
+export declare function resolveConfigPaths(cwd: string, config: RawConfig): Promise<{
+    tsx: boolean;
+    resolvedPaths: {
+        components: string;
+        cwd: string;
+    };
+}>;
+export declare function getRawConfig(cwd: string): Promise<RawConfig | null>;

package/dist/types/utils/get-package-info.d.ts

@@ -0,0 +1,2 @@
+import { type PackageJson } from "type-fest";
+export declare function getPackageInfo(cwd?: string, shouldThrow?: boolean): PackageJson | null;

package/dist/types/utils/get-package-manager.d.ts

@@ -0,0 +1,4 @@
+export declare function getPackageManager(targetDir: string, { withFallback }?: {
+    withFallback?: boolean;
+}): Promise<"yarn" | "pnpm" | "bun" | "npm" | "deno">;
+export declare function getPackageRunner(cwd: string): Promise<"pnpm dlx" | "bunx" | "npx">;

package/dist/types/utils/get-project-info.d.ts

@@ -0,0 +1,10 @@
+import { Framework } from '@/src/constants/frameworks';
+import { Config } from '@/src/utils/get-config';
+export type ProjectInfo = {
+    framework: Framework;
+    isTsx: boolean;
+    isSrcDir: boolean;
+};
+export declare function getProjectInfo(cwd: string): Promise<ProjectInfo | null>;
+export declare function isTypeScriptProject(cwd: string): Promise<boolean>;
+export declare function getProjectConfig(cwd: string, defaultProjectInfo?: ProjectInfo | null): Promise<Config | null>;

package/dist/types/utils/handle-error.d.ts

@@ -0,0 +1 @@
+export declare function handleError(error: unknown): void;

package/dist/types/utils/resolve-components-tree.d.ts

@@ -0,0 +1,4 @@
+export declare function resolveComponentsTree(components: string[]): {
+    dependencies: string[];
+    componentsDependencies: string[];
+};

package/dist/types/utils/resolve-import.d.ts

@@ -0,0 +1,2 @@
+import { type ConfigLoaderSuccessResult } from "tsconfig-paths";
+export declare function resolveImport(importPath: string, config: Pick<ConfigLoaderSuccessResult, "absoluteBaseUrl" | "paths">): Promise<string | undefined>;

package/dist/types/utils/update-dependencies.d.ts

@@ -0,0 +1,4 @@
+import { Config } from '@/src/utils/get-config';
+export declare function updateDependencies(dependencies: string[], config: Config, options: {
+    silent?: boolean;
+}): Promise<void>;

package/dist/types/utils/update-files.d.ts

@@ -0,0 +1,14 @@
+import { Config } from '@/src/utils/get-config';
+import { spinner } from '@/src/components/spinner';
+export declare function updateFiles(files: string[], config: Config, options: {
+    overwrite?: boolean;
+    force?: boolean;
+    silent?: boolean;
+    rootSpinner?: ReturnType<typeof spinner>;
+    isRemote?: boolean;
+}): Promise<{
+    filesCreated: string[];
+    filesUpdated: string[];
+    filesSkipped: string[];
+}>;
+export declare function getNormalizedFileContent(content: string): Promise<string>;

package/dist/typescript-DhnEO4aV.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { g as getDefaultExportFromCjs, r as requireTypescript } from './index.js';
+
+var typescriptExports = requireTypescript();
+var typescript = /*@__PURE__*/getDefaultExportFromCjs(typescriptExports);
+
+var typescript$1 = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	default: typescript
+});
+
+export { typescript$1 as t };

package/dist/typescript-XxXP1Woc.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+'use strict';
+
+var index = require('./index.js');
+
+var typescriptExports = index.requireTypescript();
+var typescript = /*@__PURE__*/index.getDefaultExportFromCjs(typescriptExports);
+
+var typescript$1 = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	default: typescript
+});
+
+exports.typescript = typescript$1;

package/eslint.config.js

@@ -0,0 +1,12 @@
+import { defineConfig } from "eslint/config";
+import globals from "globals";
+import js from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+
+export default defineConfig([
+  { files: ["**/*.{js,mjs,cjs,ts}"] },
+  { files: ["**/*.{js,mjs,cjs,ts}"], languageOptions: { globals: {...globals.browser, ...globals.node} } },
+  { files: ["**/*.{js,mjs,cjs,ts}"], plugins: { js }, extends: ["js/recommended"] },
+  tseslint.configs.recommended,
+]);

package/package.json

@@ -0,0 +1,67 @@
+{
+	"name": "@tavus/cvi-ui",
+	"version": "0.0.1-beta.1",
+	"description": "A CLI tool for installing and managing CVI components",
+  "publishConfig": {
+    "access": "public"
+  },
+	"keywords": [
+		"cvi",
+		"conversational-video-interface",
+		"ai-replica",
+		"react",
+		"components",
+		"hooks",
+		"tavus"
+	],
+	"author": "Tavus",
+	"license": "MIT",
+	"type": "module",
+	"scripts": {
+		"build": "rollup -c",
+		"start": "node dist/index.js",
+		"create-templates": "node prepare-scripts/create-templates.js",
+		"convert-to-js": "node prepare-scripts/convert-to-js.js",
+		"prepare": "npm run convert-to-js && npm run create-templates"
+	},
+	"main": "dist/index.js",
+	"bin": "./dist/index.js",
+	"homepage": "https://github.com/Tavus-Engineering",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/Tavus-Engineering"
+	},
+	"devDependencies": {
+		"@babel/generator": "^7.27.5",
+		"@babel/parser": "^7.27.5",
+		"@babel/traverse": "^7.27.4",
+		"@eslint/js": "^9.24.0",
+		"@rollup/plugin-commonjs": "^28.0.3",
+		"@rollup/plugin-json": "^6.1.0",
+		"@rollup/plugin-node-resolve": "^16.0.1",
+		"@rollup/plugin-typescript": "^12.1.2",
+		"@types/fs-extra": "^11.0.4",
+		"@types/node": "^22.14.0",
+		"@types/prompts": "^2.4.9",
+		"eslint": "^9.24.0",
+		"globals": "^16.0.0",
+		"prettier": "^3.5.3",
+		"rollup": "^4.41.1",
+		"rollup-plugin-copy": "^3.5.0",
+		"type-fest": "^4.39.1",
+		"typescript": "^5.8.3",
+		"typescript-eslint": "^8.29.1"
+	},
+	"dependencies": {
+		"@antfu/ni": "^24.3.0",
+		"commander": "^13.1.0",
+		"cosmiconfig": "^9.0.0",
+		"execa": "^9.5.2",
+		"fs-extra": "^11.3.0",
+		"kleur": "^4.1.5",
+		"ora": "^8.2.0",
+		"prompts": "^2.4.2",
+		"tsconfig-paths": "^4.2.0",
+		"zod": "^3.24.2"
+	}
+}

package/prepare-scripts/convert-to-js.js

@@ -0,0 +1,152 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
+import generate from '@babel/generator';
+import prettier from 'prettier';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, '..');
+
+// Function to convert TypeScript code to JavaScript by removing types
+function convertToJs(content) {
+  const ast = parse(content, {
+    sourceType: 'module',
+    plugins: ['typescript', 'jsx'],
+  });
+
+  traverse.default(ast, {
+    // Remove type annotations
+    TSTypeAnnotation(path) {
+      path.remove();
+    },
+    // Remove type parameters
+    TSTypeParameter(path) {
+      path.remove();
+    },
+    // Remove type parameter instantiation (generics like <T>)
+    TSTypeParameterInstantiation(path) {
+      path.remove();
+    },
+    // Remove interface declarations
+    TSInterfaceDeclaration(path) {
+      path.remove();
+    },
+    // Remove type declarations
+    TSTypeAliasDeclaration(path) {
+      path.remove();
+    },
+    // Remove type imports
+    ImportDeclaration(path) {
+      if (path.node.importKind === 'type') {
+        path.remove();
+      }
+    },
+    // Remove type assertions
+    TSTypeAssertion(path) {
+      path.replaceWith(path.node.expression);
+    },
+    // Remove type parameters from functions
+    TSTypeParameterDeclaration(path) {
+      path.remove();
+    },
+    // Handle non-null assertion operator (!)
+    TSNonNullExpression(path) {
+      path.replaceWith(path.node.expression);
+    },
+    // Handle type assertions
+    TSAsExpression(path) {
+      // For method calls with type assertions like (obj.method as any)(args)
+      if (path.parent.type === 'CallExpression' && path.parent.callee === path.node) {
+        const expression = path.node.expression;
+        path.parent.callee = expression;
+        path.remove();
+        return;
+      }
+      
+      // For all type assertions, just replace with the expression
+      path.replaceWith(path.node.expression);
+    }
+  });
+
+  const output = generate.default(ast, {
+    retainLines: true,
+    compact: false,
+  });
+
+  return output.code;
+}
+
+// Function to format code with Prettier
+async function formatCode(code, filePath) {
+  const config = await prettier.resolveConfig(filePath);
+  return prettier.format(code, {
+    ...config,
+    filepath: filePath,
+  });
+}
+
+// Main function to process all templates
+async function convertTemplates() {
+  const templatesDir = path.join(projectRoot, 'dev-components');
+  const outputDir = path.join(projectRoot, 'jsx-templates');
+  const components = [];
+
+  // Create output directory if it doesn't exist
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  // Process all TSX and TS files in the templates directory
+  async function processDirectory(dir) {
+    const items = fs.readdirSync(dir);
+
+    for (const item of items) {
+      const itemPath = path.join(dir, item);
+      const stat = fs.statSync(itemPath);
+
+      if (stat.isDirectory()) {
+        await processDirectory(itemPath);
+      } else if (item.endsWith('.tsx') || item.endsWith('.ts')) {
+        const relativePath = path.relative(templatesDir, itemPath);
+        const outputPath = path.join(outputDir, relativePath)
+          .replace('.tsx', '.jsx')
+          .replace('.ts', '.js');
+        
+        // Ensure the output directory exists
+        const outputDirPath = path.dirname(outputPath);
+        if (!fs.existsSync(outputDirPath)) {
+          fs.mkdirSync(outputDirPath, { recursive: true });
+        }
+
+        const content = fs.readFileSync(itemPath, 'utf-8');
+        const jsContent = convertToJs(content);
+        const formattedContent = await formatCode(jsContent, outputPath);
+        
+        fs.writeFileSync(outputPath, formattedContent);
+        console.log(`Converted: ${outputPath}`);
+        
+        components.push(outputPath);
+      } else if (item.endsWith('.css')) {
+        // Handle CSS files
+        const relativePath = path.relative(templatesDir, itemPath);
+        const outputPath = path.join(outputDir, relativePath);
+        
+        // Ensure the output directory exists
+        const outputDirPath = path.dirname(outputPath);
+        if (!fs.existsSync(outputDirPath)) {
+          fs.mkdirSync(outputDirPath, { recursive: true });
+        }
+
+        fs.copyFileSync(itemPath, outputPath);
+        console.log(`Copied CSS: ${outputPath}`);
+      }
+    }
+  }
+
+  await processDirectory(templatesDir);
+}
+
+convertTemplates().catch(console.error);