@storyteller-platform/ghost-story 0.0.1

package/dist/cli/bin.cjs

@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_zli = require("@robingenz/zli");
+var import_zod = require("zod");
+var import_config = require("./config.cjs");
+var import_install = require("./install.cjs");
+var import_whisper_server = require("./whisper-server.cjs");
+const whisperModelSchema = import_zod.z.enum(import_config.WHISPER_MODELS);
+const buildVariantSchema = import_zod.z.enum(import_config.BUILD_VARIANTS);
+function isInstallTarget(value) {
+  return ["binary", "model", "vad", "all"].includes(value);
+}
+const installCommand = (0, import_zli.defineCommand)({
+  description: `Install whisper.cpp binary and models.
+  
+Usage:
+  storywhisper install binary [variant]  - Install binary (auto-detects platform if variant not specified)
+  storywhisper install model <model>     - Install a whisper model
+  storywhisper install vad               - Install Silero VAD model
+  storywhisper install all               - Install binary, all models, and VAD`,
+  args: import_zod.z.union([
+    import_zod.z.tuple([
+      import_zod.z.enum(["binary", "model", "vad", "all"]).describe("What to install: binary, model, vad, or all")
+    ]),
+    import_zod.z.tuple([
+      import_zod.z.enum(["binary", "model", "vad", "all"]).describe("What to install: binary, model, vad, or all"),
+      import_zod.z.string().optional().describe("Variant (for binary) or model name (for model)")
+    ])
+  ]),
+  options: (0, import_zli.defineOptions)(
+    import_zod.z.object({
+      force: import_zod.z.boolean().default(false).describe("Force installation even if platform doesn't match"),
+      list: import_zod.z.boolean().default(false).describe("List available variants or models")
+    }),
+    { f: "force", l: "list" }
+  ),
+  action: async (options, args) => {
+    const [target, argument] = args;
+    const force = options.force;
+    const list = options.list;
+    if (list) {
+      if (target === "binary") {
+        console.log("Available binary variants:");
+        const compatible = (0, import_config.getCompatibleVariants)();
+        for (const variant of import_config.BUILD_VARIANTS) {
+          const isCompatible = compatible.includes(variant);
+          const marker = isCompatible ? "(compatible)" : "";
+          console.log(`  ${variant} ${marker}`);
+        }
+        console.log("\nCompatible variants for this platform:");
+        for (const variant of compatible) {
+          console.log(`  ${variant}`);
+        }
+        return;
+      }
+      if (target === "model") {
+        console.log("Available whisper models:");
+        for (const model of import_config.WHISPER_MODELS) {
+          console.log(`  ${model}`);
+        }
+        return;
+      }
+      console.error("Use --list with 'binary' or 'model'");
+      process.exit(1);
+    }
+    if (!isInstallTarget(target)) {
+      console.error(`Unknown install target: ${target}`);
+      console.error("Valid targets: binary, model, vad, all");
+      process.exit(1);
+    }
+    try {
+      if (target === "binary" || target === "all") {
+        const variant = argument && (0, import_config.isValidVariant)(argument) ? argument : void 0;
+        await (0, import_install.installBinary)({ variant, force, printOutput: true });
+      }
+      if (target === "model") {
+        if (!argument) {
+          console.error(
+            "Model name required. Usage: storywhisper install model <model>"
+          );
+          console.error("\nAvailable models:");
+          for (const m of import_config.WHISPER_MODELS) {
+            console.log(`  ${m}`);
+          }
+          process.exit(1);
+        }
+        if (!(0, import_config.isValidModel)(argument)) {
+          console.error(`Unknown model: ${argument}`);
+          console.error("\nAvailable models:");
+          for (const m of import_config.WHISPER_MODELS) {
+            console.log(`  ${m}`);
+          }
+          process.exit(1);
+        }
+        await (0, import_install.installModel)({ model: argument, force, printOutput: true });
+      }
+      if (target === "all") {
+        console.log("\nInstalling all whisper models...");
+        for (const m of import_config.WHISPER_MODELS) {
+          await (0, import_install.installModel)({ model: m, force, printOutput: true });
+        }
+      }
+      if (target === "vad" || target === "all") {
+        await (0, import_install.installVadModel)({ force, printOutput: true });
+      }
+      console.log("\nInstallation complete!");
+    } catch (error) {
+      if (error instanceof import_install.PlatformMismatchError) {
+        console.error(`Error: ${error.message}`);
+        console.error("\nCompatible variants for this platform:");
+        for (const v of error.compatibleVariants) {
+          console.log(`  ${v}`);
+        }
+        process.exit(1);
+      }
+      throw error;
+    }
+  }
+});
+const statusCommand = (0, import_zli.defineCommand)({
+  description: "Show installation status",
+  action: () => {
+    const installed = (0, import_config.getInstalledVariant)();
+    if (installed) {
+      console.log(`Installed variant: ${installed}`);
+    } else {
+      console.log("No binary installed");
+    }
+  }
+});
+const serverCommand = (0, import_zli.defineCommand)({
+  description: "Start a whisper.cpp transcription server",
+  options: (0, import_zli.defineOptions)(
+    import_zod.z.object({
+      model: whisperModelSchema.default("tiny.en").describe("Whisper model"),
+      port: import_zod.z.coerce.number().default(8080).describe("Port to listen on"),
+      host: import_zod.z.string().default("0.0.0.0").describe("Host to bind to"),
+      threads: import_zod.z.coerce.number().default(4).describe("Number of threads"),
+      processors: import_zod.z.coerce.number().default(4).describe("Number of processors"),
+      noConvert: import_zod.z.boolean().default(false).describe("Disable automatic audio conversion"),
+      noAutoInstall: import_zod.z.boolean().default(false).describe("Don't auto-install missing binary/model"),
+      variant: buildVariantSchema.optional().describe("Use specific binary variant"),
+      force: import_zod.z.boolean().default(false).describe("Force running even if platform doesn't match"),
+      vadModel: import_zod.z.string().optional().describe("Path to VAD model for voice activity detection"),
+      vadThreshold: import_zod.z.coerce.number().optional().describe("VAD threshold probability (0.0-1.0)")
+    }),
+    { m: "model", p: "port", t: "threads", f: "force" }
+  ),
+  action: async (options) => {
+    try {
+      await (0, import_whisper_server.spawnWhisperServer)({
+        model: options.model,
+        port: options.port,
+        host: options.host,
+        threads: options.threads,
+        processors: options.processors,
+        convert: !options.noConvert,
+        autoInstall: !options.noAutoInstall,
+        variant: options.variant,
+        force: options.force,
+        vadModelPath: options.vadModel,
+        vadThreshold: options.vadThreshold
+      });
+    } catch (error) {
+      if (error instanceof import_whisper_server.IncompatibleBinaryError) {
+        console.error(`Error: ${error.message}`);
+        console.error("\nCompatible variants for this platform:");
+        for (const v of (0, import_config.getCompatibleVariants)()) {
+          console.log(`  ${v}`);
+        }
+        process.exit(1);
+      }
+      throw error;
+    }
+  }
+});
+const vadCommand = (0, import_zli.defineCommand)({
+  description: "Run voice activity detection on an audio file",
+  args: import_zod.z.tuple([import_zod.z.string().describe("Input audio file path")], {
+    errorMap: (issue) => {
+      if (issue.code === "too_small") {
+        return {
+          message: "Input audio file path is required"
+        };
+      }
+      return {
+        message: "Input audio file path is required"
+      };
+    }
+  }),
+  options: (0, import_zli.defineOptions)(
+    import_zod.z.object({
+      output: import_zod.z.string().optional().describe("Output file path for VAD segments (JSON)"),
+      threshold: import_zod.z.coerce.number().default(0.5).describe("Speech detection threshold (0.0-1.0)"),
+      minSpeechDuration: import_zod.z.coerce.number().default(250).describe("Minimum speech duration in ms"),
+      minSilenceDuration: import_zod.z.coerce.number().default(100).describe("Minimum silence duration in ms"),
+      speechPad: import_zod.z.coerce.number().default(30).describe("Speech padding in ms")
+    }),
+    { o: "output" }
+  ),
+  action: async (options, args) => {
+    const [inputPath] = args;
+    const { detectVoiceActivity } = await import("../vad/Silero.cjs");
+    console.log(`Running VAD on ${inputPath}...`);
+    console.log(`  Threshold: ${options.threshold}`);
+    console.log(`  Min speech duration: ${options.minSpeechDuration}ms`);
+    console.log(`  Min silence duration: ${options.minSilenceDuration}ms`);
+    console.log(`  Speech padding: ${options.speechPad}ms`);
+    await (0, import_install.installVadModel)({ force: true, printOutput: true });
+    const segments = await detectVoiceActivity(inputPath, {
+      threshold: options.threshold,
+      minSpeechDurationMs: options.minSpeechDuration,
+      minSilenceDurationMs: options.minSilenceDuration,
+      speechPadMs: options.speechPad,
+      printOutput: true
+    });
+    if (options.output !== void 0) {
+      const { writeFile } = await import("node:fs/promises");
+      await writeFile(options.output, JSON.stringify(segments, null, 2));
+      console.log(`
+VAD segments written to ${options.output}`);
+    } else {
+      console.log("\nVAD segments:");
+      console.log(JSON.stringify(segments, null, 2));
+    }
+  }
+});
+const config = (0, import_zli.defineConfig)({
+  meta: {
+    name: "storywhisper",
+    version: import_config.WHISPER_CPP_VERSION,
+    description: `Whisper.cpp management CLI (v${import_config.WHISPER_CPP_VERSION})`
+  },
+  commands: {
+    install: installCommand,
+    status: statusCommand,
+    server: serverCommand,
+    vad: vadCommand
+  },
+  defaultCommand: statusCommand
+});
+async function main() {
+  try {
+    const result = (0, import_zli.processConfig)(config, process.argv.slice(2));
+    await result.command.action(result.options, result.args);
+  } catch (err) {
+    if (err instanceof Error) {
+      console.error("Error:", err.message);
+    } else {
+      console.error("Error:", err);
+    }
+    process.exit(1);
+  }
+}
+void main();

package/dist/cli/bin.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/bin.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli/bin.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+import {
+  defineCommand,
+  defineConfig,
+  defineOptions,
+  processConfig
+} from "@robingenz/zli";
+import { z } from "zod";
+import {
+  BUILD_VARIANTS,
+  WHISPER_CPP_VERSION,
+  WHISPER_MODELS,
+  getCompatibleVariants,
+  getInstalledVariant,
+  isValidModel,
+  isValidVariant
+} from "./config.js";
+import {
+  PlatformMismatchError,
+  installBinary,
+  installModel,
+  installVadModel
+} from "./install.js";
+import {
+  IncompatibleBinaryError,
+  spawnWhisperServer
+} from "./whisper-server.js";
+const whisperModelSchema = z.enum(WHISPER_MODELS);
+const buildVariantSchema = z.enum(BUILD_VARIANTS);
+function isInstallTarget(value) {
+  return ["binary", "model", "vad", "all"].includes(value);
+}
+const installCommand = defineCommand({
+  description: `Install whisper.cpp binary and models.
+  
+Usage:
+  storywhisper install binary [variant]  - Install binary (auto-detects platform if variant not specified)
+  storywhisper install model <model>     - Install a whisper model
+  storywhisper install vad               - Install Silero VAD model
+  storywhisper install all               - Install binary, all models, and VAD`,
+  args: z.union([
+    z.tuple([
+      z.enum(["binary", "model", "vad", "all"]).describe("What to install: binary, model, vad, or all")
+    ]),
+    z.tuple([
+      z.enum(["binary", "model", "vad", "all"]).describe("What to install: binary, model, vad, or all"),
+      z.string().optional().describe("Variant (for binary) or model name (for model)")
+    ])
+  ]),
+  options: defineOptions(
+    z.object({
+      force: z.boolean().default(false).describe("Force installation even if platform doesn't match"),
+      list: z.boolean().default(false).describe("List available variants or models")
+    }),
+    { f: "force", l: "list" }
+  ),
+  action: async (options, args) => {
+    const [target, argument] = args;
+    const force = options.force;
+    const list = options.list;
+    if (list) {
+      if (target === "binary") {
+        console.log("Available binary variants:");
+        const compatible = getCompatibleVariants();
+        for (const variant of BUILD_VARIANTS) {
+          const isCompatible = compatible.includes(variant);
+          const marker = isCompatible ? "(compatible)" : "";
+          console.log(`  ${variant} ${marker}`);
+        }
+        console.log("\nCompatible variants for this platform:");
+        for (const variant of compatible) {
+          console.log(`  ${variant}`);
+        }
+        return;
+      }
+      if (target === "model") {
+        console.log("Available whisper models:");
+        for (const model of WHISPER_MODELS) {
+          console.log(`  ${model}`);
+        }
+        return;
+      }
+      console.error("Use --list with 'binary' or 'model'");
+      process.exit(1);
+    }
+    if (!isInstallTarget(target)) {
+      console.error(`Unknown install target: ${target}`);
+      console.error("Valid targets: binary, model, vad, all");
+      process.exit(1);
+    }
+    try {
+      if (target === "binary" || target === "all") {
+        const variant = argument && isValidVariant(argument) ? argument : void 0;
+        await installBinary({ variant, force, printOutput: true });
+      }
+      if (target === "model") {
+        if (!argument) {
+          console.error(
+            "Model name required. Usage: storywhisper install model <model>"
+          );
+          console.error("\nAvailable models:");
+          for (const m of WHISPER_MODELS) {
+            console.log(`  ${m}`);
+          }
+          process.exit(1);
+        }
+        if (!isValidModel(argument)) {
+          console.error(`Unknown model: ${argument}`);
+          console.error("\nAvailable models:");
+          for (const m of WHISPER_MODELS) {
+            console.log(`  ${m}`);
+          }
+          process.exit(1);
+        }
+        await installModel({ model: argument, force, printOutput: true });
+      }
+      if (target === "all") {
+        console.log("\nInstalling all whisper models...");
+        for (const m of WHISPER_MODELS) {
+          await installModel({ model: m, force, printOutput: true });
+        }
+      }
+      if (target === "vad" || target === "all") {
+        await installVadModel({ force, printOutput: true });
+      }
+      console.log("\nInstallation complete!");
+    } catch (error) {
+      if (error instanceof PlatformMismatchError) {
+        console.error(`Error: ${error.message}`);
+        console.error("\nCompatible variants for this platform:");
+        for (const v of error.compatibleVariants) {
+          console.log(`  ${v}`);
+        }
+        process.exit(1);
+      }
+      throw error;
+    }
+  }
+});
+const statusCommand = defineCommand({
+  description: "Show installation status",
+  action: () => {
+    const installed = getInstalledVariant();
+    if (installed) {
+      console.log(`Installed variant: ${installed}`);
+    } else {
+      console.log("No binary installed");
+    }
+  }
+});
+const serverCommand = defineCommand({
+  description: "Start a whisper.cpp transcription server",
+  options: defineOptions(
+    z.object({
+      model: whisperModelSchema.default("tiny.en").describe("Whisper model"),
+      port: z.coerce.number().default(8080).describe("Port to listen on"),
+      host: z.string().default("0.0.0.0").describe("Host to bind to"),
+      threads: z.coerce.number().default(4).describe("Number of threads"),
+      processors: z.coerce.number().default(4).describe("Number of processors"),
+      noConvert: z.boolean().default(false).describe("Disable automatic audio conversion"),
+      noAutoInstall: z.boolean().default(false).describe("Don't auto-install missing binary/model"),
+      variant: buildVariantSchema.optional().describe("Use specific binary variant"),
+      force: z.boolean().default(false).describe("Force running even if platform doesn't match"),
+      vadModel: z.string().optional().describe("Path to VAD model for voice activity detection"),
+      vadThreshold: z.coerce.number().optional().describe("VAD threshold probability (0.0-1.0)")
+    }),
+    { m: "model", p: "port", t: "threads", f: "force" }
+  ),
+  action: async (options) => {
+    try {
+      await spawnWhisperServer({
+        model: options.model,
+        port: options.port,
+        host: options.host,
+        threads: options.threads,
+        processors: options.processors,
+        convert: !options.noConvert,
+        autoInstall: !options.noAutoInstall,
+        variant: options.variant,
+        force: options.force,
+        vadModelPath: options.vadModel,
+        vadThreshold: options.vadThreshold
+      });
+    } catch (error) {
+      if (error instanceof IncompatibleBinaryError) {
+        console.error(`Error: ${error.message}`);
+        console.error("\nCompatible variants for this platform:");
+        for (const v of getCompatibleVariants()) {
+          console.log(`  ${v}`);
+        }
+        process.exit(1);
+      }
+      throw error;
+    }
+  }
+});
+const vadCommand = defineCommand({
+  description: "Run voice activity detection on an audio file",
+  args: z.tuple([z.string().describe("Input audio file path")], {
+    errorMap: (issue) => {
+      if (issue.code === "too_small") {
+        return {
+          message: "Input audio file path is required"
+        };
+      }
+      return {
+        message: "Input audio file path is required"
+      };
+    }
+  }),
+  options: defineOptions(
+    z.object({
+      output: z.string().optional().describe("Output file path for VAD segments (JSON)"),
+      threshold: z.coerce.number().default(0.5).describe("Speech detection threshold (0.0-1.0)"),
+      minSpeechDuration: z.coerce.number().default(250).describe("Minimum speech duration in ms"),
+      minSilenceDuration: z.coerce.number().default(100).describe("Minimum silence duration in ms"),
+      speechPad: z.coerce.number().default(30).describe("Speech padding in ms")
+    }),
+    { o: "output" }
+  ),
+  action: async (options, args) => {
+    const [inputPath] = args;
+    const { detectVoiceActivity } = await import("../vad/Silero.js");
+    console.log(`Running VAD on ${inputPath}...`);
+    console.log(`  Threshold: ${options.threshold}`);
+    console.log(`  Min speech duration: ${options.minSpeechDuration}ms`);
+    console.log(`  Min silence duration: ${options.minSilenceDuration}ms`);
+    console.log(`  Speech padding: ${options.speechPad}ms`);
+    await installVadModel({ force: true, printOutput: true });
+    const segments = await detectVoiceActivity(inputPath, {
+      threshold: options.threshold,
+      minSpeechDurationMs: options.minSpeechDuration,
+      minSilenceDurationMs: options.minSilenceDuration,
+      speechPadMs: options.speechPad,
+      printOutput: true
+    });
+    if (options.output !== void 0) {
+      const { writeFile } = await import("node:fs/promises");
+      await writeFile(options.output, JSON.stringify(segments, null, 2));
+      console.log(`
+VAD segments written to ${options.output}`);
+    } else {
+      console.log("\nVAD segments:");
+      console.log(JSON.stringify(segments, null, 2));
+    }
+  }
+});
+const config = defineConfig({
+  meta: {
+    name: "storywhisper",
+    version: WHISPER_CPP_VERSION,
+    description: `Whisper.cpp management CLI (v${WHISPER_CPP_VERSION})`
+  },
+  commands: {
+    install: installCommand,
+    status: statusCommand,
+    server: serverCommand,
+    vad: vadCommand
+  },
+  defaultCommand: statusCommand
+});
+async function main() {
+  try {
+    const result = processConfig(config, process.argv.slice(2));
+    await result.command.action(result.options, result.args);
+  } catch (err) {
+    if (err instanceof Error) {
+      console.error("Error:", err.message);
+    } else {
+      console.error("Error:", err);
+    }
+    process.exit(1);
+  }
+}
+void main();