@tyvm/knowhow 0.0.68 → 0.0.70

package/src/clients/xai.ts

@@ -1,10 +1,25 @@
 import OpenAI from "openai";
+import { XaiTextPricing, XaiImagePricing, XaiVideoPricing } from "./pricing";
 import {
   GenericClient,
   CompletionOptions,
   CompletionResponse,
   EmbeddingOptions,
   EmbeddingResponse,
+  AudioTranscriptionOptions,
+  AudioTranscriptionResponse,
+  AudioGenerationOptions,
+  AudioGenerationResponse,
+  ImageGenerationOptions,
+  ImageGenerationResponse,
+  VideoGenerationOptions,
+  VideoGenerationResponse,
+  VideoStatusOptions,
+  VideoStatusResponse,
+  FileUploadOptions,
+  FileUploadResponse,
+  FileDownloadOptions,
+  FileDownloadResponse,
 } from "./types";
 import {
   ChatCompletionMessageParam,
@@ -78,52 +93,7 @@ export class GenericXAIClient implements GenericClient {
   }
 
   pricesPerMillion() {
-    return {
-      [Models.xai.Grok4_1_Fast_NonReasoning]: {
-        input: 0.2,
-        cache_hit: 0.05,
-        output: 0.5,
-      },
-      [Models.xai.Grok4_1_Fast_Reasoning]: {
-        input: 0.2,
-        cache_hit: 0.05,
-        output: 0.5,
-      },
-      [Models.xai.GrokCodeFast]: {
-        input: 0.2,
-        cache_hit: 0.02,
-        output: 1.5,
-      },
-      [Models.xai.Grok4]: {
-        input: 3.0,
-        output: 15.0,
-      },
-      [Models.xai.Grok3Beta]: {
-        input: 3.0,
-        output: 15.0,
-      },
-      [Models.xai.Grok3MiniBeta]: {
-        input: 0.3,
-        output: 0.5,
-      },
-      [Models.xai.Grok3FastBeta]: {
-        input: 5.0,
-        output: 25.0,
-      },
-      [Models.xai.Grok3MiniFastBeta]: {
-        input: 0.6,
-        output: 4.0,
-      },
-      [Models.xai.Grok21212]: {
-        input: 2.0,
-        output: 10.0,
-      },
-      [Models.xai.Grok2Vision1212]: {
-        input: 2.0,
-        output: 10.0,
-        image_input: 2.0,
-      },
-    };
+    return XaiTextPricing;
   }
 
   calculateCost(
@@ -163,4 +133,263 @@ export class GenericXAIClient implements GenericClient {
   async createEmbedding(options: EmbeddingOptions): Promise<EmbeddingResponse> {
     throw new Error("XAI provider does not support embeddings");
   }
+
+  async createAudioTranscription(
+    options: AudioTranscriptionOptions
+  ): Promise<AudioTranscriptionResponse> {
+    throw new Error(
+      "Audio transcription is not supported by the XAI provider. Use OpenAI client with Whisper model instead."
+    );
+  }
+
+  async createAudioGeneration(
+    options: AudioGenerationOptions
+  ): Promise<AudioGenerationResponse> {
+    throw new Error(
+      "Audio generation is not supported by the XAI provider. Use OpenAI client with TTS model instead."
+    );
+  }
+
+  async createImageGeneration(
+    options: ImageGenerationOptions
+  ): Promise<ImageGenerationResponse> {
+    const response = await this.client.images.generate({
+      model: options.model || "grok-imagine-image",
+      prompt: options.prompt,
+      n: options.n,
+      size: options.size,
+      quality: options.quality,
+      style: options.style,
+      response_format: options.response_format,
+      user: options.user,
+    });
+
+    // Calculate cost based on model name
+    const imageModel = options.model || "grok-imagine-image";
+    const costPerImage =
+      XaiImagePricing[imageModel as keyof typeof XaiImagePricing] || 0.02;
+    const usdCost = (options.n || 1) * costPerImage;
+
+    return {
+      ...response,
+      created: response.created || Math.floor(Date.now() / 1000),
+      usd_cost: usdCost,
+    };
+  }
+
+  async createVideoGeneration(
+    options: VideoGenerationOptions
+  ): Promise<VideoGenerationResponse> {
+    const model = options.model || "grok-imagine-video";
+
+    // Step 1: Start the video generation request
+    const startPayload = {
+      model,
+      prompt: options.prompt,
+    } as {
+      model: string;
+      prompt: string;
+      duration?: number;
+      aspect_ratio?: string;
+      resolution?: string;
+      image_url?: string;
+      video_url?: string;
+    };
+
+    // Add optional parameters if provided
+    if (options.duration !== undefined) {
+      startPayload.duration = options.duration;
+    }
+    if (options.aspect_ratio) {
+      startPayload.aspect_ratio = options.aspect_ratio;
+    }
+    if (options.resolution) {
+      startPayload.resolution = options.resolution;
+    }
+    if (options.image_url) {
+      startPayload.image_url = options.image_url;
+    }
+    if (options.video_url) {
+      startPayload.video_url = options.video_url;
+    }
+
+    const startResponse = await fetch(
+      "https://api.x.ai/v1/videos/generations",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify(startPayload),
+      }
+    );
+
+    if (!startResponse.ok) {
+      const errorText = await startResponse.text();
+      throw new Error(
+        `XAI video generation start failed: ${startResponse.status} ${errorText}`
+      );
+    }
+
+    const startData = await startResponse.json();
+    const requestId = startData.request_id;
+
+    if (!requestId) {
+      throw new Error("No request_id returned from XAI video generation start");
+    }
+
+    // Return immediately with the jobId – do NOT poll here.
+    // Use getVideoStatus() to poll and downloadVideo() to fetch the result.
+    const duration = options.duration || 5;
+    const pricePerSecond = XaiVideoPricing[model] || 0.07;
+    const usdCost = duration * pricePerSecond;
+
+    return {
+      created: Math.floor(Date.now() / 1000),
+      data: [],
+      jobId: requestId,
+      usd_cost: usdCost,
+    };
+  }
+
+  async getVideoStatus(
+    options: VideoStatusOptions
+  ): Promise<VideoStatusResponse> {
+    const statusResponse = await fetch(
+      `https://api.x.ai/v1/videos/${options.jobId}`,
+      {
+        method: "GET",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+      }
+    );
+
+    if (!statusResponse.ok) {
+      const errorText = await statusResponse.text();
+      throw new Error(
+        `XAI video status check failed: ${statusResponse.status} ${errorText}`
+      );
+    }
+
+    const statusData = await statusResponse.json();
+
+    // Map XAI status to standard status
+    let mappedStatus: "queued" | "in_progress" | "completed" | "failed" | "expired";
+    switch (statusData.status) {
+      case "pending":
+        mappedStatus = "queued";
+        break;
+      case "processing":
+        mappedStatus = "in_progress";
+        break;
+      case "succeeded":
+        mappedStatus = "completed";
+        break;
+      case "failed":
+        mappedStatus = "failed";
+        break;
+      case "expired":
+        mappedStatus = "expired";
+        break;
+      default:
+        mappedStatus = "queued";
+    }
+
+    const response: VideoStatusResponse = {
+      jobId: options.jobId,
+      status: mappedStatus,
+    };
+
+    // If completed, include the video URL
+    if (mappedStatus === "completed" && statusData.video?.url) {
+      response.data = [
+        {
+          url: statusData.video.url,
+        },
+      ];
+    }
+
+    return response;
+  }
+
+  async downloadVideo(
+    options: FileDownloadOptions
+  ): Promise<FileDownloadResponse> {
+    // XAI returns a URL for the video, not raw bytes from their API
+    const url = options.uri || options.fileId;
+
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to download video from XAI URL: ${response.status} ${response.statusText}`
+      );
+    }
+
+    const arrayBuffer = await response.arrayBuffer();
+    return {
+      data: Buffer.from(arrayBuffer),
+      mimeType: "video/mp4",
+    };
+  }
+
+  async uploadFile(
+    options: FileUploadOptions
+  ): Promise<FileUploadResponse> {
+    const apiKey = this.apiKey || process.env.XAI_API_KEY;
+    if (!apiKey) {
+      throw new Error("XAI API key not set");
+    }
+
+    const formData = new FormData();
+    formData.append("purpose", "assistants");
+    const blob = new Blob([options.data], { type: options.mimeType || "application/octet-stream" });
+    formData.append("file", blob, options.fileName || "upload");
+
+    const response = await fetch("https://api.x.ai/v1/files", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${apiKey}` },
+      body: formData,
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`XAI uploadFile failed: ${response.status} ${errorText}`);
+    }
+
+    const data = await response.json();
+    return { fileId: data.id, uri: data.uri };
+  }
+
+  async downloadFile(
+    options: FileDownloadOptions
+  ): Promise<FileDownloadResponse> {
+    const apiKey = this.apiKey || process.env.XAI_API_KEY;
+    if (!apiKey) {
+      throw new Error("XAI API key not set");
+    }
+
+    const fileId = options.fileId;
+    if (!fileId) {
+      throw new Error("downloadFile requires fileId");
+    }
+
+    const response = await fetch(`https://api.x.ai/v1/files/${fileId}/content`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${apiKey}` },
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`XAI downloadFile failed: ${response.status} ${errorText}`);
+    }
+
+    const mimeType = response.headers.get("content-type") || undefined;
+    const data = Buffer.from(await response.arrayBuffer());
+    return {
+      data,
+      mimeType,
+    };
+  }
 }

package/src/config.ts

@@ -12,23 +12,30 @@ import {
   EmbeddingModels,
 } from "./types";
 import { mkdir, writeFile, readFile, fileExists } from "./utils";
+import { applyMigrations } from "./migrations";
 
 const defaultConfig = {
   promptsDir: ".knowhow/prompts",
   modules: [],
-  plugins: [
-    "embeddings",
-    "language",
-    "git",
-    "vim",
-    "github",
-    "asana",
-    "jira",
-    "linear",
-    "download",
-    "figma",
-    "url",
-  ],
+  plugins: {
+    enabled: [
+      "embeddings",
+      "language",
+      "git",
+      "vim",
+      "github",
+      "asana",
+      "jira",
+      "linear",
+      "download",
+      "figma",
+      "url",
+      "tmux",
+      "agents-md",
+      "exec",
+    ],
+    disabled: [],
+  },
   lintCommands: {
     js: "eslint",
     ts: "tslint",
@@ -169,6 +176,7 @@ export async function getLanguageConfig() {
     );
     return language as Language;
   } catch (e) {
+    console.error("Error reading .knowhow/language.json:", e);
     return {} as Language;
   }
 }
@@ -217,7 +225,14 @@ export function getConfigSync() {
     const config = JSON.parse(
       fs.readFileSync(".knowhow/knowhow.json", "utf8").toString()
     );
-    return config as Config;
+
+    // Apply migrations synchronously
+    const { config: migratedConfig } = applyMigrations(config);
+
+    // Note: We don't save here in sync mode to avoid blocking operations
+    // The async getConfig() will handle saving on next call
+
+    return migratedConfig as Config;
   } catch (e) {
     return {} as Config;
   }
@@ -238,13 +253,44 @@ export async function getConfig() {
   }
   try {
     const config = await readFile(".knowhow/knowhow.json", "utf8");
-    return JSON.parse(config) as Config;
+    const parsedConfig = JSON.parse(config);
+
+    return parsedConfig as Config;
   } catch (error) {
     console.error("Error reading .knowhow/knowhow.json:", error);
     throw new Error("Failed to load KnowHow configuration.");
   }
 }
 
+export async function migrateConfig() {
+  // Apply migrations, used to keep config structure up to date.
+  const parsedConfig = await getConfig();
+  const { modified, config: migratedConfig } = applyMigrations(parsedConfig);
+
+  // After migrations, check if any plugins from defaultConfig are missing
+  let configModified = modified;
+  if (migratedConfig.plugins) {
+    const enabled = migratedConfig.plugins.enabled || [];
+    const disabled = migratedConfig.plugins.disabled || [];
+    const missingPlugins = defaultConfig.plugins.enabled.filter(
+      (plugin) => !enabled.includes(plugin) && !disabled.includes(plugin)
+    );
+
+    if (missingPlugins.length > 0) {
+      console.log(
+        `Adding missing plugins to enabled list: ${missingPlugins.join(", ")}`
+      );
+      migratedConfig.plugins.enabled = [...enabled, ...missingPlugins];
+      configModified = true;
+    }
+  }
+
+  // If migrations were applied, save the updated config
+  if (configModified) {
+    await updateConfig(migratedConfig);
+  }
+}
+
 export async function loadPrompt(promptName: string) {
   const config = await getConfig();
   if (!promptName) {

package/src/embeddings.ts

@@ -27,7 +27,15 @@ export { cosineSimilarity };
 
 export async function loadEmbedding(filePath: string) {
   if (await fileExists(filePath)) {
-    return JSON.parse(await readFile(filePath, "utf8")) as Embeddable[];
+    try {
+      const parsed = JSON.parse(
+        await readFile(filePath, "utf8")
+      ) as Embeddable[];
+      return parsed;
+    } catch (e) {
+      console.error("Error loading embedding file", filePath, e);
+      return [];
+    }
   }
   return [];
 }

package/src/microphone.ts

@@ -77,7 +77,7 @@ export async function recordAudio() {
   const filePath = "/tmp/knowhow.wav";
   const audioFile = fs.createWriteStream(filePath, { encoding: "binary" });
   const defaultMic = getDefaultMic();
-  const hasSox = await execAsync("which sox");
+  const hasSox = await execAsync("which sox").catch(() => false);
 
   if (!hasSox && !defaultMic) {
     console.error("Sox is required to record audio");
@@ -117,26 +117,25 @@ sudo apt-get install sox libsox-fmt-all
 }
 
 export async function voiceToText() {
-  let input = await ask(
-    "Press Enter to Start Recording, or exit to quit...: ",
-    ["exit"]
-  );
-
-  if (input === "exit") {
-    return "/voice";
+  // Allow user to type commands to exit voice mode or press Enter to record
+  const startInput = await ask("Press Enter to Start Recording (or type a command to exit): ", []);
+  
+  // If user typed anything other than empty string, return it (e.g., /voice, /exit, etc.)
+  if (startInput.trim() !== "") {
+    return startInput;
   }
-
+  
   const recording = await recordAudio();
   console.log("Recording audio...");
-  input = await ask("Press Enter to Stop Recording, or exit to quit...: ", [
-    "exit",
-  ]);
+  
+  const stopInput = await ask("Press Enter to Stop Recording (or type a command to cancel): ", []);
   recording.stop();
   console.log("Stopped recording");
-
-  if (input === "exit") {
-    return "/voice";
+  
+  // If user typed anything during recording, return it instead of transcribing
+  if (stopInput.trim() !== "") {
+    return stopInput;
   }
-
+  
   return convertAudioToText("/tmp/knowhow.wav", false);
 }

package/src/migrations.ts

@@ -0,0 +1,151 @@
+/**
+ * Configuration Migration System
+ * 
+ * This module provides a framework for migrating configuration files
+ * as the schema evolves over time. Each migration is a function that
+ * transforms the config and returns whether it made changes.
+ */
+
+import { Config } from "./types";
+
+export type Migration = {
+  version: number;
+  description: string;
+  migrate: (config: any, context?: MigrationContext) => { modified: boolean; config: any };
+};
+
+export type MigrationContext = {
+  allPluginKeys?: string[];
+};
+
+/**
+ * Default list of all known plugins at time of migration
+ * This list is used if the migration context doesn't provide plugin keys
+ */
+const DEFAULT_PLUGINS = [
+  "embeddings",
+  "language",
+  "git",
+  "vim",
+  "linter",
+  "github",
+  "asana",
+  "jira",
+  "linear",
+  "notion",
+  "download",
+  "figma",
+  "url",
+  "tmux",
+  "agents-md",
+];
+
+/**
+ * Migration 1: Convert plugins from string[] to { enabled, disabled } format
+ * Also ensures all registered plugins are in the enabled list
+ */
+const migration1: Migration = {
+  version: 1,
+  description: "Convert plugins from string[] to { enabled, disabled } format and add missing plugins",
+  migrate: (config: any, context?: MigrationContext) => {
+    const allPluginKeys = context?.allPluginKeys || DEFAULT_PLUGINS;
+    let modified = false;
+
+    // If plugins doesn't exist, no migration needed
+    if (!config.plugins) {
+      // Create default plugins config with all plugins enabled
+      config.plugins = {
+        enabled: [...allPluginKeys],
+        disabled: [],
+      };
+      return { modified: true, config };
+    }
+
+    // If plugins is a string array, convert it
+    if (Array.isArray(config.plugins)) {
+      config.plugins = {
+        enabled: config.plugins,
+        disabled: [],
+      };
+      modified = true;
+    }
+
+    // Ensure config.plugins is an object with enabled/disabled arrays
+    if (typeof config.plugins === "object" && !Array.isArray(config.plugins)) {
+      // Ensure enabled array exists
+      if (!config.plugins.enabled) {
+        config.plugins.enabled = [...allPluginKeys];
+        modified = true;
+      }
+
+      // Ensure disabled array exists
+      if (!config.plugins.disabled) {
+        config.plugins.disabled = [];
+        modified = true;
+      }
+
+      // Add any missing plugins to enabled list
+      const missingPlugins = allPluginKeys.filter(
+        (key) =>
+          !config.plugins.enabled.includes(key) &&
+          !config.plugins.disabled.includes(key)
+      );
+      
+      if (missingPlugins.length > 0) {
+        config.plugins.enabled.push(...missingPlugins);
+        modified = true;
+      }
+    }
+
+    return { modified, config };
+  },
+};
+
+/**
+ * All migrations in order
+ */
+export const migrations: Migration[] = [migration1];
+
+/**
+ * Apply all migrations to a config object
+ * @param config The config object to migrate
+ * @param context Optional context for migrations (e.g., list of all plugin keys)
+ * @returns Object containing the migrated config and whether any changes were made
+ */
+export function applyMigrations(config: any, context?: MigrationContext): {
+  modified: boolean;
+  config: any;
+} {
+  let modified = false;
+  let currentConfig = { ...config };
+
+  for (const migration of migrations) {
+    try {
+      const result = migration.migrate(currentConfig, context);
+      if (result.modified) {
+        console.log(
+          `Applied migration ${migration.version}: ${migration.description}`
+        );
+        modified = true;
+        currentConfig = result.config;
+      }
+    } catch (error) {
+      console.error(
+        `Failed to apply migration ${migration.version}: ${migration.description}`,
+        error
+      );
+      // Continue with other migrations even if one fails
+    }
+  }
+
+  return { modified, config: currentConfig };
+}
+
+/**
+ * Get the current migration version (highest migration number)
+ */
+export function getCurrentMigrationVersion(): number {
+  return migrations.length > 0
+    ? Math.max(...migrations.map((m) => m.version))
+    : 0;
+}