@mistweaverco/kulala-core 0.1.5 → 0.18.0

package/dist/cli.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { spawnSync } from "node:child_process";
+
+// src/lib/downloader/index.ts
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { chmodSync, createWriteStream } from "node:fs";
+import { pipeline } from "node:stream/promises";
+
+// src/versions/backend.ts
+var KULALA_CORE_VERSION = "0.18.0";
+
+// src/lib/downloader/index.ts
+var PACKAGE_ROOT = path.dirname(fileURLToPath(import.meta.url));
+var BINARY_NAME = "kulala-core";
+var DOWNLOAD_URL = "https://github.com/mistweaverco/kulala-core/releases/download/v%s/%s";
+function platform() {
+  const os = process.platform === "darwin" ? "darwin" : process.platform === "win32" ? "windows" : "linux";
+  const arch = process.arch;
+  let archName = arch;
+  if (arch === "x64") {
+    archName = "x86_64";
+  } else if (arch === "arm64") {
+    archName = os === "darwin" ? "arm64" : "aarch64";
+  }
+  return `${os}-${archName}`;
+}
+function getBinDir() {
+  return path.join(PACKAGE_ROOT, "bin");
+}
+function getReleaseBinName() {
+  const name = `${BINARY_NAME}-${platform()}`;
+  return process.platform === "win32" ? `${name}.exe` : name;
+}
+function getBinName() {
+  return process.platform === "win32" ? `${BINARY_NAME}.exe` : BINARY_NAME;
+}
+function getBinPath() {
+  return path.join(getBinDir(), getBinName());
+}
+function getVersionPath() {
+  return path.join(getBinDir(), "version.txt");
+}
+function getLocalDevBinaryPath() {
+  const candidates = [
+    path.join(PACKAGE_ROOT, "..", "core", "dist", "kulala-core"),
+    path.join(PACKAGE_ROOT, "..", "..", "core", "dist", "kulala-core")
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function binaryExists() {
+  return fs.existsSync(getBinPath());
+}
+function getInstalledVersion() {
+  const versionPath = getVersionPath();
+  if (!fs.existsSync(versionPath)) {
+    return null;
+  }
+  return fs.readFileSync(versionPath, "utf-8").trim();
+}
+function versionMatches() {
+  const installed = getInstalledVersion();
+  return installed === KULALA_CORE_VERSION;
+}
+function makeExecutable(filePath) {
+  if (process.platform !== "win32") {
+    chmodSync(filePath, 493);
+  }
+}
+var SPINNER_FRAMES = [
+  "⠋",
+  "⠙",
+  "⠹",
+  "⠸",
+  "⠼",
+  "⠴",
+  "⠦",
+  "⠧",
+  "⠇",
+  "⠏"
+];
+function isInteractiveTerminal() {
+  return process.stderr.isTTY === true;
+}
+function createDownloadProgress() {
+  let timer;
+  let frame = 0;
+  let message = "";
+  const clearLine = () => {
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    if (isInteractiveTerminal()) {
+      process.stderr.write("\r\x1B[K");
+    }
+  };
+  return {
+    start(msg) {
+      message = msg;
+      if (!isInteractiveTerminal()) {
+        console.error(message);
+        return;
+      }
+      const render = () => {
+        process.stderr.write(`\r${SPINNER_FRAMES[frame]} ${message}`);
+        frame = (frame + 1) % SPINNER_FRAMES.length;
+      };
+      render();
+      timer = setInterval(render, 80);
+    },
+    succeed(msg) {
+      clearLine();
+      console.error(msg);
+    },
+    fail() {
+      clearLine();
+    }
+  };
+}
+async function downloadFile(url, outputPath) {
+  const response = await fetch(url);
+  if (!response.ok || !response.body) {
+    throw new Error(`Failed to download kulala-core from ${url}: ${response.status} ${response.statusText}`);
+  }
+  await pipeline(response.body, createWriteStream(outputPath));
+}
+function removeStaleBinary() {
+  if (!binaryExists()) {
+    return;
+  }
+  fs.unlinkSync(getBinPath());
+  const versionPath = getVersionPath();
+  if (fs.existsSync(versionPath)) {
+    fs.unlinkSync(versionPath);
+  }
+}
+async function installBackend() {
+  const binDir = getBinDir();
+  fs.mkdirSync(binDir, { recursive: true });
+  const releaseName = getReleaseBinName();
+  const url = DOWNLOAD_URL.replace("%s", KULALA_CORE_VERSION).replace("%s", releaseName);
+  const downloadPath = path.join(binDir, `${releaseName}.download`);
+  const binPath = getBinPath();
+  const progress = createDownloadProgress();
+  progress.start(`Downloading kulala-core v${KULALA_CORE_VERSION}...`);
+  try {
+    await downloadFile(url, downloadPath);
+    makeExecutable(downloadPath);
+    fs.renameSync(downloadPath, binPath);
+    fs.writeFileSync(getVersionPath(), KULALA_CORE_VERSION, "utf-8");
+    progress.succeed(`Installed kulala-core to ${binPath}`);
+  } catch (error) {
+    progress.fail();
+    throw error;
+  }
+}
+async function tryInstallBackend() {
+  const fromEnv = process.env.KULALA_CORE_PATH;
+  if (fromEnv && fromEnv.length > 0) {
+    return;
+  }
+  if (getLocalDevBinaryPath()) {
+    return;
+  }
+  if (binaryExists() && versionMatches()) {
+    return;
+  }
+  if (binaryExists()) {
+    removeStaleBinary();
+  }
+  try {
+    await installBackend();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Warning: failed to download kulala-core during install: ${message}`);
+    console.error("@mistweaverco/kulala-core will attempt to download it on first use instead.");
+  }
+}
+async function ensureInstalled() {
+  const fromEnv = process.env.KULALA_CORE_PATH;
+  if (fromEnv && fromEnv.length > 0) {
+    if (!fs.existsSync(fromEnv)) {
+      throw new Error(`KULALA_CORE_PATH does not exist: ${fromEnv}`);
+    }
+    return fromEnv;
+  }
+  const localDevBinary = getLocalDevBinaryPath();
+  if (localDevBinary) {
+    return localDevBinary;
+  }
+  if (binaryExists() && versionMatches()) {
+    return getBinPath();
+  }
+  if (binaryExists()) {
+    removeStaleBinary();
+  }
+  await installBackend();
+  return getBinPath();
+}
+var downloader = {
+  ensureInstalled,
+  getBinPath,
+  installBackend,
+  tryInstallBackend
+};
+
+// src/cli.ts
+async function main() {
+  const executable = await downloader.ensureInstalled();
+  const result = spawnSync(executable, process.argv.slice(2), {
+    stdio: "inherit",
+    env: process.env
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  process.exit(result.status ?? 1);
+}
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(message);
+  process.exit(1);
+});

package/dist/index.d.ts

@@ -1,33 +1,2 @@
-export { KulalaParser, writeErrorToStderr } from "./lib/parser";
-export { KulalaRunner } from "./lib/runner";
-export type { KulalaDocument } from "./lib/parser/types";
-export type { KulalaStdinParsed } from "./lib/parser/types/stdinparsed";
-export type { KulalaRunOptions } from "./lib/runner";
-export type { KulalaRequestErrorResponse, KulalaRequestSuccessResponse, KulalaResponseWrapper, } from "./lib/runner";
-import type { KulalaStdinActionRunLimit } from "./lib/parser/types/stdinparsed";
-import type { KulalaResponseWrapper, KulalaRunOptions } from "./lib/runner";
-import type { KulalaDocument } from "./lib/parser/types";
-export declare const kulalaCore: {
-    readonly parser: import("./lib/parser/types").KulalaParser;
-    readonly runner: {
-        run: (doc: KulalaDocument, limit?: KulalaStdinActionRunLimit[], options?: KulalaRunOptions) => Promise<void>;
-    };
-    readonly parse: (input: {
-        content: string;
-        filepath?: string;
-    }) => Promise<KulalaDocument>;
-    readonly validate: (input: {
-        content: string;
-        filepath?: string;
-    }) => Promise<KulalaDocument>;
-    readonly run: (input: {
-        content: string;
-        filepath?: string;
-        env?: string;
-        limit?: KulalaStdinActionRunLimit[];
-    }) => Promise<{
-        doc: KulalaDocument;
-        response: KulalaResponseWrapper;
-    }>;
-};
-//# sourceMappingURL=index.d.ts.map
+export { kulalaCore } from "./lib/kulala-core";
+export type { InvokeOptions, KulalaDocument, KulalaFormatInput, KulalaHttpFormatResult, KulalaParseInput, KulalaRequestErrorResponse, KulalaRequestSuccessResponse, KulalaResponseItem, KulalaResponseWrapper, KulalaRunInput, RunLimit, } from "./lib/kulala-core";