mirai-cli 0.1.0

package/bin/config.ts

@@ -0,0 +1,99 @@
+/* ─── Config loader ───
+ *   Reads ~/.mirai/config.yaml, merges with built-in PROVIDERS.
+ */
+
+import { readFileSync, existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { PROVIDERS, readBaseUrl, readApiKey } from "@mirai/llm";
+
+/* ─── Types ─── */
+
+export interface ProviderEntry {
+  /** Base URL for API calls */
+  baseURL?: string;
+  /** API key (optional — if unset, env {ID}_API_KEY is used, or no auth) */
+  apiKey?: string;
+  /** Default model for this provider (optional) */
+  default?: string;
+  /** Allowed models (optional — for display / autocomplete) */
+  models?: string[];
+}
+
+export interface MiraiConfig {
+  /** Default model in "providerID/modelID" format */
+  default?: string;
+  /** Custom providers (key = provider ID) */
+  providers: Record<string, ProviderEntry>;
+}
+
+/* ─── Load ─── */
+
+const CONFIG_PATH = join(homedir(), ".mirai", "config.yaml");
+
+export async function loadConfig(): Promise<MiraiConfig> {
+  // Start with empty config
+  const config: MiraiConfig = { providers: {} };
+
+  if (!existsSync(CONFIG_PATH)) {
+    return config;
+  }
+
+  try {
+    // Dynamic import js-yaml (ESM)
+    const { load: yamlLoad } = await import("js-yaml");
+    const raw = readFileSync(CONFIG_PATH, "utf-8");
+    const parsed = yamlLoad(raw) as Record<string, unknown>;
+
+    if (parsed?.default && typeof parsed.default === "string") {
+      config.default = parsed.default;
+    }
+
+    if (parsed?.providers && typeof parsed.providers === "object") {
+      for (const [id, entry] of Object.entries(parsed.providers)) {
+        const e = entry as Record<string, unknown>;
+        config.providers[id] = {
+          baseURL: typeof e.baseURL === "string" ? e.baseURL : undefined,
+          apiKey: typeof e.apiKey === "string" ? e.apiKey : undefined,
+          default: typeof e.default === "string" ? e.default : undefined,
+          models: Array.isArray(e.models) ? (e.models as string[]) : undefined,
+        };
+      }
+    }
+
+    return config;
+  } catch (err) {
+    console.error(`[mirai] Failed to load config from ${CONFIG_PATH}:`, (err as Error).message);
+    return config;
+  }
+}
+
+/* ─── Merge custom over built-in ─── */
+
+export function getProviderConfig(id: string, config: MiraiConfig) {
+  // Custom provider from user config — overrides built-in
+  if (config.providers[id]) {
+    const entry = config.providers[id];
+    return {
+      name: id,
+      baseURL: entry.baseURL ?? "http://127.0.0.1:11434/v1",
+      apiKey: entry.apiKey ?? process.env[`${id.toUpperCase()}_API_KEY`],
+      supportsReasoning: false,
+      noAuth: !(entry.apiKey || process.env[`${id.toUpperCase()}_API_KEY`]),
+    };
+  }
+
+  // Built-in provider
+  const builtin = PROVIDERS[id];
+  if (builtin) {
+    return {
+      name: builtin.name,
+      baseURL: readBaseUrl(builtin),
+      apiKey: readApiKey(builtin) ?? undefined,
+      supportsReasoning: builtin.supportsReasoning ?? false,
+      noAuth: builtin.noAuth ?? false,
+    };
+  }
+
+  return null;
+}

package/bin/mirai.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { existsSync } from "fs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const dist = join(__dirname, "..", "dist", "mirai.mjs");
+const src = join(__dirname, "mirai.ts");
+
+if (existsSync(dist)) {
+  await import(dist);
+} else {
+  const { spawn } = await import("child_process");
+  spawn("pnpm", ["exec", "tsx", src, ...process.argv.slice(2)], {
+    stdio: "inherit",
+  }).on("exit", (code) => process.exit(code ?? 0));
+}

package/bin/mirai.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env tsx
+import { main } from "./router.js";
+
+main();

package/bin/provider.ts

@@ -0,0 +1,149 @@
+/* ─── Provider detection (hybrid) ───
+ *
+ * Priority:
+ *   1. Model has "providerID/" prefix → route directly
+ *   2. OLLAMA_HOST env set → Ollama
+ *   3. OPENAI_BASE_URL env set → OpenAI custom
+ *   4. Model prefix detect (gpt-*, grok*, claude*, qwen-*)
+ *   5. API key env sniff
+ *   6. Config default provider
+ *   7. Fallback → Ollama local
+ */
+
+import { PROVIDERS, readBaseUrl, readApiKey } from "@mirai/llm";
+import type { MiraiConfig } from "./config.js";
+import { getProviderConfig } from "./config.js";
+
+export interface ProviderInfo {
+  id: string;
+  name: string;
+  baseURL: string;
+  apiKey?: string;
+  supportsReasoning: boolean;
+  noAuth: boolean;
+  model: string;
+}
+
+/* ─── Model prefix → built-in provider map ─── */
+
+const PREFIX_MAP: [string, string][] = [
+  ["gpt-", "openai"],
+  ["openai/", "openai"],
+  ["grok", "xai"],
+  ["claude", "anthropic"],
+  ["anthropic/", "anthropic"],
+  ["qwen-", "dashscope"],
+  ["qwen/", "dashscope"],
+  ["kimi", "dashscope"],
+  ["deepseek", "deepseek"],
+  ["llama-", "groq"],
+  ["mixtral", "groq"],
+  ["gemma", "groq"],
+];
+
+/* ─── Main detection logic ─── */
+
+export function resolveProvider(model: string, config: MiraiConfig): ProviderInfo {
+  // 1. Explicit "providerID/modelID" prefix
+  const slashIdx = model.indexOf("/");
+  if (slashIdx > 0) {
+    const providerId = model.slice(0, slashIdx);
+    const modelId = model.slice(slashIdx + 1);
+    const resolved = getProviderConfig(providerId, config);
+    if (resolved) {
+      return {
+        id: providerId,
+        ...resolved,
+        model: modelId,
+      };
+    }
+    // Provider not found — continue to detect / fallback
+  }
+
+  // 2. OLLAMA_HOST env set → Ollama
+  if (process.env.OLLAMA_HOST) {
+    const ollama = PROVIDERS.ollama;
+    return {
+      id: "ollama",
+      name: ollama.name,
+      baseURL: readBaseUrl(ollama),
+      apiKey: undefined,
+      supportsReasoning: false,
+      noAuth: true,
+      model,
+    };
+  }
+
+  // 3. OPENAI_BASE_URL env set (custom OpenAI-compatible)
+  if (process.env.OPENAI_BASE_URL) {
+    return {
+      id: "openai",
+      name: "OpenAI (custom)",
+      baseURL: process.env.OPENAI_BASE_URL,
+      apiKey: process.env.OPENAI_API_KEY ?? undefined,
+      supportsReasoning: false,
+      noAuth: !process.env.OPENAI_API_KEY,
+      model,
+    };
+  }
+
+  // 4. Model prefix detection
+  for (const [prefix, providerId] of PREFIX_MAP) {
+    if (model.startsWith(prefix)) {
+      const builtin = PROVIDERS[providerId];
+      if (builtin) {
+        return {
+          id: providerId,
+          name: builtin.name,
+          baseURL: readBaseUrl(builtin),
+          apiKey: readApiKey(builtin) ?? undefined,
+          supportsReasoning: builtin.supportsReasoning ?? false,
+          noAuth: builtin.noAuth ?? false,
+          model,
+        };
+      }
+    }
+  }
+
+  // 5. API key env sniff
+  const keyProviders: [string, string][] = [
+    ["OPENAI_API_KEY", "openai"],
+    ["XAI_API_KEY", "xai"],
+    ["DASHSCOPE_API_KEY", "dashscope"],
+    ["GROQ_API_KEY", "groq"],
+    ["DEEPSEEK_API_KEY", "deepseek"],
+  ];
+  for (const [envKey, providerId] of keyProviders) {
+    if (process.env[envKey]) {
+      const builtin = PROVIDERS[providerId];
+      if (builtin) {
+        return {
+          id: providerId,
+          name: builtin.name,
+          baseURL: readBaseUrl(builtin),
+          apiKey: process.env[envKey]!,
+          supportsReasoning: builtin.supportsReasoning ?? false,
+          noAuth: false,
+          model,
+        };
+      }
+    }
+  }
+
+  // 6. Config default — if not already resolved (avoid recursion)
+  if (config.default && config.default.includes("/")) {
+    return resolveProvider(config.default, config);
+  }
+
+  // 7. Fallback → Ollama local
+  const ollama = PROVIDERS.ollama;
+  return {
+    id: "ollama",
+    name: ollama.name,
+    baseURL: readBaseUrl(ollama),
+    apiKey: undefined,
+    supportsReasoning: false,
+    noAuth: true,
+    model,
+  };
+}

package/bin/router.ts

@@ -0,0 +1,134 @@
+/* ─── Mirai CLI router ───
+ *   Entry from bin/mirai.ts
+ *   Parses args, loads config, detects provider, boots TUI or web
+ */
+
+import { loadConfig, type MiraiConfig } from "./config.js";
+import { resolveProvider, type ProviderInfo } from "./provider.js";
+import { DEFAULT_MODEL } from "@mirai/core/constants";
+
+const HELP = `
+Usage:
+  mirai                        Start TUI (default)
+  mirai --model <model>        Start TUI with specific model
+  mirai --web                  Start web interface
+  mirai --web --model <m>      Web + model
+  mirai --help                 Show this help
+  mirai --version              Show version
+
+Examples:
+  mirai --model openai/gpt-4.1-mini
+  mirai --model groq/llama-4
+  mirai --web
+`;
+
+export async function main(): Promise<void> {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.help) {
+    console.log(HELP);
+    process.exit(0);
+  }
+
+  if (args.version) {
+    console.log("mirai v1.0.0");
+    process.exit(0);
+  }
+
+  // 1. Load config
+  const config = await loadConfig();
+
+  // 2. Resolve model (priority: CLI > env > config > hardcode)
+  const model =
+    args.model ?? process.env.DEFAULT_MODEL ?? config.default ?? DEFAULT_MODEL;
+
+  // 3. Resolve provider for this model
+  const provider = resolveProvider(model, config);
+
+  // 4. Boot
+  if (args.web) {
+    await bootWeb(model, provider, config);
+  } else {
+    await bootTui(model, provider, config);
+  }
+}
+
+/* ─── Args parsing ─── */
+
+interface CliArgs {
+  model?: string;
+  web: boolean;
+  help: boolean;
+  version: boolean;
+}
+
+function parseArgs(argv: string[]): CliArgs {
+  const args: CliArgs = { web: false, help: false, version: false };
+
+  for (let i = 0; i < argv.length; i++) {
+    switch (argv[i]) {
+      case "--model":
+      case "-m":
+        args.model = argv[++i];
+        break;
+      case "--web":
+      case "-w":
+        args.web = true;
+        break;
+      case "--help":
+      case "-h":
+        args.help = true;
+        break;
+      case "--version":
+      case "-v":
+        args.version = true;
+        break;
+    }
+  }
+
+  return args;
+}
+
+/* ─── Boot TUI ─── */
+
+async function bootTui(
+  model: string,
+  _provider: ProviderInfo,
+  _config: MiraiConfig,
+): Promise<void> {
+  const { render } = await import("ink");
+  const { createElement } = await import("react");
+  const { default: App } = await import("../src/app/index.js");
+  const { mouseInput } = await import("../src/services/mouse-input.js");
+
+  mouseInput.onExit(() => process.exit(0));
+  mouseInput.enable();
+
+  const stdin = Object.assign(mouseInput.stdin, {
+    isTTY: true as const,
+    setRawMode: (mode: boolean) => process.stdin.setRawMode?.(mode),
+    ref: () => process.stdin.ref?.(),
+    unref: () => process.stdin.unref?.(),
+  }) as unknown as NodeJS.ReadStream;
+
+  const { waitUntilExit } = render(createElement(App, { model }), {
+    stdin,
+    interactive: true,
+    alternateScreen: true,
+    maxFps: 140,
+  });
+
+  await waitUntilExit();
+  mouseInput.disable();
+}
+
+/* ─── Boot Web ─── */
+
+async function bootWeb(
+  _model: string,
+  _provider: ProviderInfo,
+  _config: MiraiConfig,
+): Promise<void> {
+  console.log("[mirai] Web mode coming soon — use without --web for TUI");
+  process.exit(0);
+}