@novastorm-ai/cli 0.0.1

package/dist/bin/nova.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import {
+  run
+} from "../chunk-NFNZMCLQ.js";
+import "../chunk-FYSTZ6K6.js";
+import "../chunk-3RG5ZIWI.js";
+
+// bin/nova.ts
+run().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/dist/chunk-3RG5ZIWI.js

@@ -0,0 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};

package/dist/chunk-FYSTZ6K6.js

@@ -0,0 +1,231 @@
+// src/setup.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { select, password } from "@inquirer/prompts";
+import TOML2 from "@iarna/toml";
+
+// src/config.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import TOML from "@iarna/toml";
+import {
+  ConfigError,
+  DEFAULT_CONFIG
+} from "@novastorm-ai/core";
+var NOVA_TOML = "nova.toml";
+var LOCAL_CONFIG_PATH = path.join(".nova", "config.toml");
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const srcVal = source[key];
+    if (srcVal === void 0) continue;
+    const tgtVal = result[key];
+    if (typeof srcVal === "object" && srcVal !== null && !Array.isArray(srcVal) && typeof tgtVal === "object" && tgtVal !== null && !Array.isArray(tgtVal)) {
+      result[key] = deepMerge(
+        tgtVal,
+        srcVal
+      );
+    } else {
+      result[key] = srcVal;
+    }
+  }
+  return result;
+}
+async function readTomlFile(filePath) {
+  let content;
+  try {
+    content = await fs.readFile(filePath, "utf-8");
+  } catch {
+    return {};
+  }
+  try {
+    return TOML.parse(content);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new ConfigError(`Invalid TOML in ${filePath}: ${message}`);
+  }
+}
+function validateRelativePath(value, field) {
+  if (value.includes("..")) {
+    throw new ConfigError(
+      `Path traversal not allowed in ${field}: "${value}"`,
+      field
+    );
+  }
+  if (path.isAbsolute(value)) {
+    throw new ConfigError(
+      `Absolute paths not allowed in ${field}: "${value}". Use a relative path.`,
+      field
+    );
+  }
+}
+function validate(config) {
+  if (config.project.port < 0 || config.project.port > 65535) {
+    throw new ConfigError(
+      `Invalid port number: ${config.project.port}. Must be between 0 and 65535.`,
+      "project.port"
+    );
+  }
+  const validProviders = ["openrouter", "anthropic", "openai", "ollama", "claude-cli"];
+  if (!validProviders.includes(config.apiKeys.provider)) {
+    throw new ConfigError(
+      `Invalid provider: ${config.apiKeys.provider}. Must be one of: ${validProviders.join(", ")}`,
+      "apiKeys.provider"
+    );
+  }
+  const validEngines = ["web", "whisper"];
+  if (!validEngines.includes(config.voice.engine)) {
+    throw new ConfigError(
+      `Invalid voice engine: ${config.voice.engine}. Must be one of: ${validEngines.join(", ")}`,
+      "voice.engine"
+    );
+  }
+  if (typeof config.telemetry.enabled !== "boolean") {
+    throw new ConfigError(
+      `Invalid telemetry.enabled: must be a boolean.`,
+      "telemetry.enabled"
+    );
+  }
+  if (config.project.frontend !== void 0) {
+    validateRelativePath(config.project.frontend, "project.frontend");
+  }
+  if (config.project.backends !== void 0) {
+    if (!Array.isArray(config.project.backends)) {
+      throw new ConfigError(
+        "project.backends must be an array of strings.",
+        "project.backends"
+      );
+    }
+    for (const backend of config.project.backends) {
+      if (typeof backend !== "string") {
+        throw new ConfigError(
+          "Each entry in project.backends must be a string.",
+          "project.backends"
+        );
+      }
+      validateRelativePath(backend, "project.backends");
+    }
+  }
+}
+function diffFromDefaults(config) {
+  const result = {};
+  const defaults = DEFAULT_CONFIG;
+  const input = config;
+  for (const section of Object.keys(input)) {
+    const sectionValues = input[section];
+    if (!sectionValues || typeof sectionValues !== "object") continue;
+    const defaultSection = defaults[section];
+    const diff = {};
+    for (const [key, value] of Object.entries(sectionValues)) {
+      if (defaultSection && defaultSection[key] === value) continue;
+      diff[key] = value;
+    }
+    if (Object.keys(diff).length > 0) {
+      result[section] = diff;
+    }
+  }
+  return result;
+}
+var ConfigReader = class {
+  async read(projectPath) {
+    const projectTomlPath = path.join(projectPath, NOVA_TOML);
+    const localTomlPath = path.join(projectPath, LOCAL_CONFIG_PATH);
+    const projectData = await readTomlFile(projectTomlPath);
+    const localData = await readTomlFile(localTomlPath);
+    let merged = deepMerge(
+      DEFAULT_CONFIG,
+      projectData
+    );
+    merged = deepMerge(merged, localData);
+    const envApiKey = process.env["NOVA_API_KEY"];
+    if (envApiKey !== void 0) {
+      const apiKeys = merged["apiKeys"];
+      apiKeys["key"] = envApiKey;
+    }
+    const config = merged;
+    validate(config);
+    return config;
+  }
+  async write(projectPath, config) {
+    const diff = diffFromDefaults(config);
+    const tomlString = TOML.stringify(diff);
+    const filePath = path.join(projectPath, NOVA_TOML);
+    await fs.writeFile(filePath, tomlString, "utf-8");
+  }
+  async writeLocal(projectPath, config) {
+    const diff = diffFromDefaults(config);
+    const tomlString = TOML.stringify(diff);
+    const filePath = path.join(projectPath, LOCAL_CONFIG_PATH);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, tomlString, "utf-8");
+  }
+  async exists(projectPath) {
+    try {
+      await fs.stat(path.join(projectPath, NOVA_TOML));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/setup.ts
+import { DEFAULT_CONFIG as DEFAULT_CONFIG2 } from "@novastorm-ai/core";
+var NOVA_DIR = ".nova";
+var LOCAL_CONFIG = "config.toml";
+async function runSetup(projectPath) {
+  const cwd = projectPath ?? process.cwd();
+  console.log("Welcome to Nova Architect setup!\n");
+  let provider;
+  let apiKey;
+  try {
+    provider = await select({
+      message: "Select your AI provider:",
+      choices: [
+        { name: "Claude CLI (uses your Claude Max/Pro subscription)", value: "claude-cli" },
+        { name: "OpenRouter (recommended \u2014 access to all models)", value: "openrouter" },
+        { name: "Anthropic", value: "anthropic" },
+        { name: "OpenAI", value: "openai" },
+        { name: "Ollama (free, local)", value: "ollama" }
+      ]
+    });
+    console.log(`Selected provider: ${provider}`);
+    if (provider !== "ollama" && provider !== "claude-cli") {
+      apiKey = await password({
+        message: `Enter your ${provider} API key:`,
+        mask: "*"
+      });
+      if (!apiKey || apiKey.trim().length === 0) {
+        console.log("No API key provided. You can set it later in .nova/config.toml");
+        apiKey = void 0;
+      }
+    }
+  } catch {
+    console.log("\nSetup cancelled.");
+    return;
+  }
+  const novaDir = path2.join(cwd, NOVA_DIR);
+  await fs2.mkdir(novaDir, { recursive: true });
+  const localConfig = {
+    apiKeys: { provider }
+  };
+  if (apiKey) {
+    localConfig["apiKeys"]["key"] = apiKey;
+  }
+  const localConfigPath = path2.join(novaDir, LOCAL_CONFIG);
+  await fs2.writeFile(localConfigPath, TOML2.stringify(localConfig), "utf-8");
+  console.log(`
+Saved provider config to ${localConfigPath}`);
+  const configReader = new ConfigReader();
+  const exists = await configReader.exists(cwd);
+  if (!exists) {
+    await configReader.write(cwd, DEFAULT_CONFIG2);
+    console.log(`Created ${path2.join(cwd, "nova.toml")} with default configuration.`);
+  }
+  console.log("\nSetup complete!");
+}
+
+export {
+  ConfigReader,
+  runSetup
+};