varg.ai-sdk 0.1.1 → 0.4.0-alpha.1

package/src/cli/commands/which.tsx

@@ -0,0 +1,253 @@
+/**
+ * varg which command
+ * Ink-based inspection view
+ */
+
+import { defineCommand } from "citty";
+import { Box, Text } from "ink";
+import { resolve } from "../../core/registry/resolver.ts";
+import { getCliSchemaInfo, toJsonSchema } from "../../core/schema/helpers.ts";
+import type {
+  ActionDefinition,
+  Definition,
+  ModelDefinition,
+  SkillDefinition,
+} from "../../core/schema/types.ts";
+import {
+  Badge,
+  Header,
+  OptionRow,
+  Separator,
+  VargBox,
+  VargText,
+} from "../ui/index.ts";
+import { renderStatic } from "../ui/render.ts";
+import { theme } from "../ui/theme.ts";
+
+interface WhichViewProps {
+  item: Definition;
+}
+
+function InputSchemaView({ schema }: { schema: unknown }) {
+  // biome-ignore lint/suspicious/noExplicitAny: Zod v4 type compatibility
+  const { properties, required } = getCliSchemaInfo(schema as any);
+  return (
+    <>
+      <Header>INPUT SCHEMA</Header>
+      <Box flexDirection="column" paddingLeft={2} marginBottom={1}>
+        {Object.entries(properties).map(([key, prop]) => (
+          <OptionRow
+            key={key}
+            name={key}
+            description={prop.description}
+            required={required.includes(key)}
+            defaultValue={prop.default}
+            enumValues={prop.enum}
+            type={prop.type}
+          />
+        ))}
+      </Box>
+    </>
+  );
+}
+
+function OutputSchemaView({ schema }: { schema: unknown }) {
+  // biome-ignore lint/suspicious/noExplicitAny: Zod v4 type compatibility
+  const jsonSchema = toJsonSchema(schema as any);
+  return (
+    <>
+      <Header>OUTPUT</Header>
+      <Box paddingLeft={2} marginBottom={1}>
+        <Text>{jsonSchema.description || "Output result"}</Text>
+      </Box>
+    </>
+  );
+}
+
+function WhichView({ item }: WhichViewProps) {
+  return (
+    <VargBox title={item.name}>
+      <Box marginBottom={1}>
+        <Text>{item.description}</Text>
+      </Box>
+
+      <Header>TYPE</Header>
+      <Box paddingLeft={2} marginBottom={1}>
+        <Badge type={item.type} />
+      </Box>
+
+      {/* Providers for models */}
+      {item.type === "model" && (
+        <>
+          <Header>PROVIDERS</Header>
+          <Box flexDirection="column" paddingLeft={2} marginBottom={1}>
+            <Text>{(item as ModelDefinition).providers.join(", ")}</Text>
+            <Text dimColor>
+              default: {(item as ModelDefinition).defaultProvider}
+            </Text>
+          </Box>
+        </>
+      )}
+
+      {/* Routes for actions */}
+      {item.type === "action" &&
+        (item as ActionDefinition).routes.length > 0 && (
+          <>
+            <Header>ROUTES</Header>
+            <Box flexDirection="column" paddingLeft={2} marginBottom={1}>
+              {(item as ActionDefinition).routes.map((route) => (
+                <Box key={route.target}>
+                  <Text>
+                    {"\u2192"} {route.target}
+                  </Text>
+                  {route.when && (
+                    <Text dimColor> when {JSON.stringify(route.when)}</Text>
+                  )}
+                </Box>
+              ))}
+            </Box>
+          </>
+        )}
+
+      {/* Steps for skills */}
+      {item.type === "skill" && (
+        <>
+          <Header>STEPS</Header>
+          <Box flexDirection="column" paddingLeft={2} marginBottom={1}>
+            {(item as SkillDefinition).steps.map((step, index) => (
+              <Box key={step.name}>
+                <Text>
+                  {index + 1}. {step.name} {"\u2192"} {step.run}
+                </Text>
+              </Box>
+            ))}
+          </Box>
+        </>
+      )}
+
+      {/* Input schema */}
+      <InputSchemaView schema={item.schema.input} />
+
+      {/* Output */}
+      <OutputSchemaView schema={item.schema.output} />
+
+      <Separator />
+      <Box marginTop={1}>
+        <Text dimColor>run with </Text>
+        <Text color={theme.colors.accent}>varg run {item.name} [options]</Text>
+      </Box>
+    </VargBox>
+  );
+}
+
+function NotFoundView({
+  name,
+  suggestions,
+}: {
+  name: string;
+  suggestions?: string[];
+}) {
+  return (
+    <Box flexDirection="column" padding={1}>
+      <VargText variant="error">not found: '{name}'</VargText>
+      {suggestions && suggestions.length > 0 && (
+        <Box marginTop={1}>
+          <Text>did you mean: {suggestions.slice(0, 3).join(", ")}?</Text>
+        </Box>
+      )}
+    </Box>
+  );
+}
+
+/** Help view for which command */
+function WhichHelpView() {
+  return (
+    <VargBox title="varg which">
+      <Box marginBottom={1}>
+        <Text>inspect a model, action, or skill</Text>
+      </Box>
+
+      <Header>USAGE</Header>
+      <Box paddingLeft={2} marginBottom={1}>
+        <VargText variant="accent">varg which {"<name>"} [--json]</VargText>
+      </Box>
+
+      <Header>ARGUMENTS</Header>
+      <Box flexDirection="column" paddingLeft={2} marginBottom={1}>
+        <Text>name name of item to inspect</Text>
+      </Box>
+
+      <Header>OPTIONS</Header>
+      <Box flexDirection="column" paddingLeft={2} marginBottom={1}>
+        <Text>--json output as json</Text>
+      </Box>
+
+      <Header>EXAMPLES</Header>
+      <Box flexDirection="column" paddingLeft={2}>
+        <Box flexDirection="column" marginBottom={1}>
+          <Text dimColor># inspect video action</Text>
+          <VargText variant="accent">varg which video</VargText>
+        </Box>
+        <Box flexDirection="column">
+          <Text dimColor># get json schema</Text>
+          <VargText variant="accent">varg which flux --json</VargText>
+        </Box>
+      </Box>
+    </VargBox>
+  );
+}
+
+/** Show which command help */
+export function showWhichHelp() {
+  renderStatic(<WhichHelpView />);
+}
+
+export const whichCmd = defineCommand({
+  meta: {
+    name: "which",
+    description: "inspect a model, action, or skill",
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "name to inspect",
+      required: false,
+    },
+    json: {
+      type: "boolean",
+      description: "output as json",
+    },
+  },
+  async run({ args, rawArgs }) {
+    // Handle --help
+    if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+      showWhichHelp();
+      return;
+    }
+
+    const name = args.name as string;
+
+    if (!name) {
+      showWhichHelp();
+      return;
+    }
+
+    const result = resolve(name, { fuzzy: true });
+
+    if (!result.definition) {
+      renderStatic(
+        <NotFoundView name={name} suggestions={result.suggestions} />,
+      );
+      process.exit(1);
+    }
+
+    const item = result.definition;
+
+    if (args.json) {
+      console.log(JSON.stringify(item, null, 2));
+      return;
+    }
+
+    renderStatic(<WhichView item={item} />);
+  },
+});

package/src/cli/index.ts

@@ -0,0 +1,114 @@
+#!/usr/bin/env bun
+
+/**
+ * varg cli
+ * ai video infrastructure from your terminal
+ */
+
+// Must be first import to suppress logs before other modules load
+import "./quiet";
+
+import { defineCommand, runMain } from "citty";
+import { registry } from "../core/registry";
+import { allDefinitions } from "../definitions";
+import {
+  findCmd,
+  helpCmd,
+  listCmd,
+  renderCmd,
+  runCmd,
+  showFindHelp,
+  showHelp,
+  showListHelp,
+  showRunHelp,
+  showTargetHelp,
+  showWhichHelp,
+  whichCmd,
+} from "./commands";
+
+// Register all providers
+import "../providers"; // Side effect: registers providers to base registry
+import { providers } from "../providers/base";
+
+// Register all definitions
+for (const definition of allDefinitions) {
+  registry.register(definition);
+}
+
+// Also register providers to core registry
+for (const provider of providers.all()) {
+  registry.registerProvider(provider);
+}
+
+// Intercept --help and -h to use our custom help views
+const args = process.argv.slice(2);
+const hasHelp = args.includes("--help") || args.includes("-h");
+
+// Map subcommands to their help functions
+const subcommandHelp: Record<string, () => void> = {
+  run: showRunHelp,
+  list: showListHelp,
+  ls: showListHelp,
+  find: showFindHelp,
+  search: showFindHelp,
+  which: showWhichHelp,
+  inspect: showWhichHelp,
+};
+
+// Handle help for root or subcommands
+if (args.length === 0 || args[0] === "help") {
+  showHelp();
+  process.exit(0);
+}
+
+if (hasHelp) {
+  const subcommand = args[0];
+  // Root --help
+  if (subcommand === "--help" || subcommand === "-h") {
+    showHelp();
+    process.exit(0);
+  }
+
+  // Handle subcommand help
+  if (subcommand && subcommand in subcommandHelp) {
+    const nonHelpArgs = args.filter((a) => a !== "--help" && a !== "-h");
+
+    // "varg run --help" - show run help
+    if (nonHelpArgs.length === 1) {
+      const helpFn = subcommandHelp[subcommand];
+      if (helpFn) {
+        helpFn();
+        process.exit(0);
+      }
+    }
+
+    // "varg run <target> --help" - show target-specific help
+    if (subcommand === "run" && nonHelpArgs.length === 2) {
+      const target = nonHelpArgs[1];
+      if (target && showTargetHelp(target)) {
+        process.exit(0);
+      }
+    }
+  }
+}
+
+const main = defineCommand({
+  meta: {
+    name: "varg",
+    version: "0.3.0",
+    description: "ai video infrastructure from your terminal",
+  },
+  subCommands: {
+    run: runCmd,
+    render: renderCmd,
+    list: listCmd,
+    ls: listCmd,
+    find: findCmd,
+    search: findCmd,
+    which: whichCmd,
+    inspect: whichCmd,
+    help: helpCmd,
+  },
+});
+
+runMain(main);

package/src/cli/quiet.ts

@@ -0,0 +1,44 @@
+/**
+ * Quiet mode setup - must be imported first
+ * Suppresses console.log for --json and --quiet modes
+ */
+
+const args = process.argv.slice(2);
+export const isQuietMode = args.includes("--json") || args.includes("--quiet");
+
+// Store original write function
+const _originalWrite = process.stdout.write.bind(process.stdout);
+
+if (isQuietMode) {
+  // Override process.stdout.write to filter non-JSON output
+  process.stdout.write = ((
+    // biome-ignore lint/suspicious/noExplicitAny: complex overload signature
+    chunk: any,
+    // biome-ignore lint/suspicious/noExplicitAny: complex overload signature
+    encoding?: any,
+    // biome-ignore lint/suspicious/noExplicitAny: complex overload signature
+    callback?: any,
+  ): boolean => {
+    const str = typeof chunk === "string" ? chunk : chunk.toString();
+    const trimmed = str.trim();
+
+    // Only allow JSON output (starts with { or [) or empty lines
+    if (trimmed === "" || trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      return _originalWrite(chunk, encoding, callback);
+    }
+
+    // Suppress non-JSON output, still call callback if provided
+    if (typeof encoding === "function") {
+      encoding();
+    } else if (callback) {
+      callback();
+    }
+    return true;
+  }) as typeof process.stdout.write;
+}
+
+// Export for direct output when needed (bypasses quiet mode)
+export function rawLog(...args: unknown[]): void {
+  const message = `${args.map(String).join(" ")}\n`;
+  _originalWrite(message);
+}

package/src/cli/types.ts

@@ -0,0 +1,32 @@
+/**
+ * CLI type definitions
+ */
+
+export interface NotFoundOptions {
+  /** Suggested alternatives */
+  suggestions?: string[];
+  /** Max number of suggestions to show */
+  maxSuggestions?: number;
+  /** Custom hint message */
+  hint?: string;
+  /** Color function for error text */
+  errorColorFn?: (s: string) => string;
+  /** Color function for hints */
+  hintColorFn?: (s: string) => string;
+  /** Whether to exit process (default: true) */
+  exit?: boolean;
+}
+
+export interface JsonSchemaProperty {
+  type?: string;
+  description?: string;
+  default?: unknown;
+  enum?: string[];
+}
+
+export interface JsonSchema {
+  type?: string;
+  properties?: Record<string, JsonSchemaProperty>;
+  required?: string[];
+  description?: string;
+}

package/src/cli/ui/components/Badge.tsx

@@ -0,0 +1,29 @@
+/**
+ * Badge - Type indicator badge
+ * Shows [model] [action] [skill] with appropriate styling
+ */
+
+import { Text } from "ink";
+import { theme } from "../theme.ts";
+
+type BadgeType = "model" | "action" | "skill";
+
+interface BadgeProps {
+  type: BadgeType;
+}
+
+const badgeColors: Record<BadgeType, string> = {
+  model: theme.colors.accent,
+  action: theme.colors.success,
+  skill: theme.colors.warning,
+};
+
+export function Badge({ type }: BadgeProps) {
+  return (
+    <Text color={badgeColors[type]} dimColor>
+      [{type}]
+    </Text>
+  );
+}
+
+export default Badge;

package/src/cli/ui/components/DataTable.tsx

@@ -0,0 +1,51 @@
+/**
+ * DataTable - Table display component
+ * Clean text-based table for listing items
+ */
+
+import { Box, Text } from "ink";
+import { Badge } from "./Badge.tsx";
+import { VargText } from "./VargText.tsx";
+
+interface TableRow {
+  name: string;
+  description: string;
+  type?: "model" | "action" | "skill";
+}
+
+interface DataTableProps {
+  rows: TableRow[];
+  showType?: boolean;
+}
+
+export function DataTable({ rows, showType = false }: DataTableProps) {
+  if (rows.length === 0) {
+    return (
+      <Box paddingLeft={2}>
+        <VargText variant="muted">no items</VargText>
+      </Box>
+    );
+  }
+
+  // Calculate max name width for alignment
+  const maxNameWidth = Math.max(...rows.map((r) => r.name.length), 12);
+
+  return (
+    <Box flexDirection="column">
+      {rows.map((row) => (
+        <Box key={row.name} paddingLeft={2}>
+          {showType && row.type && (
+            <>
+              <Badge type={row.type} />
+              <Text> </Text>
+            </>
+          )}
+          <Text bold>{row.name.padEnd(maxNameWidth)}</Text>
+          <VargText variant="muted"> {row.description}</VargText>
+        </Box>
+      ))}
+    </Box>
+  );
+}
+
+export default DataTable;

package/src/cli/ui/components/Header.tsx

@@ -0,0 +1,23 @@
+/**
+ * Header - Section header component
+ * Bold dimmed text for section titles
+ */
+
+import { Box, Text } from "ink";
+import type { ReactNode } from "react";
+
+interface HeaderProps {
+  children: ReactNode;
+}
+
+export function Header({ children }: HeaderProps) {
+  return (
+    <Box>
+      <Text bold dimColor>
+        {children}
+      </Text>
+    </Box>
+  );
+}
+
+export default Header;

package/src/cli/ui/components/HelpBlock.tsx

@@ -0,0 +1,44 @@
+/**
+ * HelpBlock - Command help and examples
+ * Displays usage patterns and command examples
+ */
+
+import { Box, Text } from "ink";
+import { VargText } from "./VargText.tsx";
+
+interface HelpBlockProps {
+  usage?: string;
+  examples?: Array<{ command: string; description?: string }>;
+}
+
+export function HelpBlock({ usage, examples }: HelpBlockProps) {
+  return (
+    <Box flexDirection="column">
+      {usage && (
+        <Box marginBottom={1}>
+          <VargText variant="muted">usage: </VargText>
+          <VargText variant="accent">{usage}</VargText>
+        </Box>
+      )}
+
+      {examples && examples.length > 0 && (
+        <Box flexDirection="column">
+          {examples.map((ex) => (
+            <Box key={ex.command} flexDirection="column" marginBottom={1}>
+              {ex.description && (
+                <Box paddingLeft={2}>
+                  <Text dimColor># {ex.description}</Text>
+                </Box>
+              )}
+              <Box paddingLeft={2}>
+                <VargText variant="accent">{ex.command}</VargText>
+              </Box>
+            </Box>
+          ))}
+        </Box>
+      )}
+    </Box>
+  );
+}
+
+export default HelpBlock;

package/src/cli/ui/components/KeyValue.tsx

@@ -0,0 +1,33 @@
+/**
+ * KeyValue - Label-value pair display
+ * Aligned key-value pairs with optional required marker
+ */
+
+import { Box, Text } from "ink";
+import { theme } from "../theme.ts";
+
+interface KeyValueProps {
+  label: string;
+  value: string;
+  labelWidth?: number;
+  required?: boolean;
+}
+
+export function KeyValue({
+  label,
+  value,
+  labelWidth = theme.layout.optionNameWidth,
+  required = false,
+}: KeyValueProps) {
+  const paddedLabel = label.padEnd(labelWidth);
+
+  return (
+    <Box>
+      <Text dimColor>{paddedLabel}</Text>
+      {required && <Text color={theme.colors.warning}>* </Text>}
+      <Text>{value}</Text>
+    </Box>
+  );
+}
+
+export default KeyValue;