@curenorway/kode-cli 1.18.0 → 2.0.0

package/dist/chunk-MUW33LPZ.js

@@ -0,0 +1,265 @@
+// src/commands/pkg.ts
+import chalk from "chalk";
+import { existsSync, readFileSync, readdirSync, statSync, mkdirSync, writeFileSync, rmSync } from "fs";
+import { join, relative, dirname, extname } from "path";
+function getConfig() {
+  const configPath = join(process.cwd(), ".cure-kode", "config.json");
+  if (!existsSync(configPath)) return null;
+  const config = JSON.parse(readFileSync(configPath, "utf-8"));
+  return {
+    siteId: config.siteId,
+    apiKey: config.apiKey,
+    apiUrl: config.apiUrl || "https://app.cure.no",
+    scriptsDir: join(process.cwd(), ".cure-kode-scripts")
+  };
+}
+async function apiRequest(config, path, options = {}) {
+  const url = `${config.apiUrl}${path}`;
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      "Content-Type": "application/json",
+      "X-API-Key": config.apiKey,
+      ...options.headers || {}
+    }
+  });
+  if (!response.ok) {
+    const err = await response.json().catch(() => ({ error: response.statusText }));
+    throw new Error(err.error || `HTTP ${response.status}`);
+  }
+  return response.json();
+}
+async function pkgAddCommand(name) {
+  const config = getConfig();
+  if (!config) return console.log(chalk.red("Not in a Kode project. Run kode init first."));
+  try {
+    console.log(chalk.dim(`Fetching @kode/${name}...`));
+    const pkg = await apiRequest(config, `/api/cdn/packages/${name}`);
+    if (!pkg.files?.length) {
+      return console.log(chalk.red(`Package "${name}" has no files.`));
+    }
+    const pkgDir = join(config.scriptsDir, "packages", "@kode", pkg.slug);
+    mkdirSync(pkgDir, { recursive: true });
+    for (const file of pkg.files) {
+      const filePath = join(pkgDir, file.path);
+      mkdirSync(dirname(filePath), { recursive: true });
+      writeFileSync(filePath, file.content, "utf-8");
+    }
+    writeFileSync(join(pkgDir, "kode.json"), JSON.stringify({
+      name: pkg.name,
+      slug: pkg.slug,
+      version: pkg.version,
+      description: pkg.description,
+      entryPoint: pkg.entry_point,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }, null, 2) + "\n");
+    console.log(chalk.green(`\u2714 Installed @kode/${pkg.slug} v${pkg.version}`));
+    console.log(chalk.dim(`  ${pkg.files.length} file(s) \u2192 .cure-kode-scripts/packages/@kode/${pkg.slug}/`));
+    console.log(chalk.dim(`  Import: import { ... } from '@kode/${pkg.slug}'`));
+  } catch (err) {
+    console.log(chalk.red(`Error: ${err.message}`));
+  }
+}
+async function pkgRemoveCommand(name) {
+  const config = getConfig();
+  if (!config) return console.log(chalk.red("Not in a Kode project. Run kode init first."));
+  const pkgDir = join(config.scriptsDir, "packages", "@kode", name);
+  if (!existsSync(pkgDir)) {
+    return console.log(chalk.red(`Package "@kode/${name}" is not installed.`));
+  }
+  rmSync(pkgDir, { recursive: true, force: true });
+  console.log(chalk.green(`\u2714 Removed @kode/${name}`));
+}
+async function pkgPublishCommand(options) {
+  const config = getConfig();
+  if (!config) return console.log(chalk.red("Not in a Kode project. Run kode init first."));
+  if (!options.path) return console.log(chalk.red("Usage: kode pkg publish --path <path> --slug <slug>"));
+  if (!options.slug) return console.log(chalk.red("Usage: kode pkg publish --path <path> --slug <slug>"));
+  const sourcePath = join(config.scriptsDir, options.path);
+  if (!existsSync(sourcePath)) {
+    return console.log(chalk.red(`Path not found: ${options.path}`));
+  }
+  const files = [];
+  const stat = statSync(sourcePath);
+  if (stat.isFile()) {
+    const ext = extname(sourcePath);
+    files.push({ path: `index${ext}`, content: readFileSync(sourcePath, "utf-8") });
+  } else {
+    collectFiles(sourcePath, sourcePath, files);
+  }
+  if (files.length === 0) {
+    return console.log(chalk.red("No files found."));
+  }
+  const entryNames = ["index.ts", "index.tsx", "index.jsx", "index.js"];
+  const entryPoint = files.find((f) => entryNames.includes(f.path))?.path || files[0].path;
+  const displayName = options.slug.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+  const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : void 0;
+  try {
+    console.log(chalk.dim(`Publishing ${files.length} file(s) as @kode/${options.slug}...`));
+    const result = await apiRequest(config, "/api/cdn/packages", {
+      method: "POST",
+      body: JSON.stringify({
+        name: displayName,
+        slug: options.slug,
+        description: options.description,
+        entryPoint,
+        files,
+        tags
+      })
+    });
+    const verb = result.created ? "Published" : "Updated";
+    console.log(chalk.green(`\u2714 ${verb} @kode/${result.slug} v${result.version}`));
+    console.log(chalk.dim(`  ${files.length} file(s), entry: ${entryPoint}`));
+    console.log(chalk.dim(`  Install: kode pkg add ${result.slug}`));
+  } catch (err) {
+    console.log(chalk.red(`Error: ${err.message}`));
+  }
+}
+async function pkgListCommand() {
+  const config = getConfig();
+  if (!config) return console.log(chalk.red("Not in a Kode project. Run kode init first."));
+  try {
+    const packages = await apiRequest(config, "/api/cdn/packages");
+    const installedDir = join(config.scriptsDir, "packages", "@kode");
+    const installed = existsSync(installedDir) ? readdirSync(installedDir) : [];
+    if (packages.length === 0) {
+      return console.log(chalk.dim("No packages in registry."));
+    }
+    console.log(chalk.bold(`\u{1F4E6} Packages (${packages.length}):
+`));
+    for (const pkg of packages) {
+      const isInstalled = installed.includes(pkg.slug);
+      const status = isInstalled ? chalk.green(" \u2714") : "";
+      const tags = pkg.tags?.length ? chalk.dim(` [${pkg.tags.join(", ")}]`) : "";
+      console.log(`  ${chalk.cyan(pkg.slug)} v${pkg.version}${status} \u2014 ${pkg.description || chalk.dim("No description")}${tags}`);
+    }
+  } catch (err) {
+    console.log(chalk.red(`Error: ${err.message}`));
+  }
+}
+async function pkgInfoCommand(name) {
+  const config = getConfig();
+  if (!config) return console.log(chalk.red("Not in a Kode project. Run kode init first."));
+  try {
+    const pkg = await apiRequest(config, `/api/cdn/packages/${name}`);
+    const installedDir = join(config.scriptsDir, "packages", "@kode", pkg.slug);
+    const isInstalled = existsSync(installedDir);
+    console.log(chalk.bold(`
+\u{1F4E6} @kode/${pkg.slug} v${pkg.version}`));
+    console.log(`   Name: ${pkg.name}`);
+    if (pkg.description) console.log(`   Description: ${pkg.description}`);
+    console.log(`   Entry: ${pkg.entry_point}`);
+    if (pkg.tags?.length) console.log(`   Tags: ${pkg.tags.join(", ")}`);
+    console.log(`   Installs: ${pkg.install_count}`);
+    console.log(`   Status: ${isInstalled ? chalk.green("Installed") : chalk.dim("Not installed")}`);
+    if (pkg.files?.length) {
+      console.log(`   Files:`);
+      for (const f of pkg.files) {
+        console.log(chalk.dim(`     ${f.path}`));
+      }
+    }
+  } catch (err) {
+    console.log(chalk.red(`Error: ${err.message}`));
+  }
+}
+async function pkgUpdateCommand(name) {
+  const config = getConfig();
+  if (!config) return console.log(chalk.red("Not in a Kode project. Run kode init first."));
+  const pkgDir = join(config.scriptsDir, "packages", "@kode", name);
+  if (!existsSync(pkgDir)) {
+    return console.log(chalk.red(`Package "@kode/${name}" is not installed.`));
+  }
+  let currentVersion = 0;
+  const manifestPath = join(pkgDir, "kode.json");
+  if (existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+      currentVersion = manifest.version || 0;
+    } catch {
+    }
+  }
+  try {
+    const pkg = await apiRequest(config, `/api/cdn/packages/${name}`);
+    if (pkg.version <= currentVersion) {
+      return console.log(chalk.dim(`@kode/${name} is already up to date (v${currentVersion}).`));
+    }
+    await pkgAddCommand(name);
+  } catch (err) {
+    console.log(chalk.red(`Error: ${err.message}`));
+  }
+}
+function collectFiles(baseDir, currentDir, files) {
+  for (const entry of readdirSync(currentDir, { withFileTypes: true })) {
+    const fullPath = join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      if (!["node_modules", ".git", "dist"].includes(entry.name)) {
+        collectFiles(baseDir, fullPath, files);
+      }
+    } else if (entry.isFile()) {
+      files.push({ path: relative(baseDir, fullPath), content: readFileSync(fullPath, "utf-8") });
+    }
+  }
+}
+async function restorePackages() {
+  const config = getConfig();
+  if (!config) return;
+  const scriptsDir = config.scriptsDir;
+  if (!existsSync(scriptsDir)) return;
+  const importRegex = /from\s+['"]@kode\/([^'"\/]+)['"]/g;
+  const neededPackages = /* @__PURE__ */ new Set();
+  for (const entry of readdirSync(scriptsDir, { withFileTypes: true })) {
+    if (!entry.isFile()) continue;
+    if (![".ts", ".tsx", ".js", ".jsx"].includes(extname(entry.name))) continue;
+    const content = readFileSync(join(scriptsDir, entry.name), "utf-8");
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      neededPackages.add(match[1]);
+    }
+  }
+  if (neededPackages.size === 0) return;
+  const packagesDir = join(scriptsDir, "packages", "@kode");
+  const installed = existsSync(packagesDir) ? readdirSync(packagesDir) : [];
+  const builtin = ["webflow"];
+  const missing = [...neededPackages].filter(
+    (pkg) => !builtin.includes(pkg) && !installed.includes(pkg)
+  );
+  if (missing.length === 0) return;
+  const spinner = (await import("ora")).default(`Gjenoppretter ${missing.length} pakke(r)...`).start();
+  let restored = 0;
+  for (const slug of missing) {
+    try {
+      const pkg = await apiRequest(config, `/api/cdn/packages/${slug}`);
+      if (!pkg?.files) continue;
+      const pkgDir = join(packagesDir, slug);
+      mkdirSync(pkgDir, { recursive: true });
+      for (const file of pkg.files) {
+        const filePath = join(pkgDir, file.path);
+        mkdirSync(dirname(filePath), { recursive: true });
+        writeFileSync(filePath, file.content, "utf-8");
+      }
+      writeFileSync(join(pkgDir, "kode.json"), JSON.stringify({
+        name: pkg.name || slug,
+        version: String(pkg.version || "1"),
+        description: pkg.description || "",
+        entryPoint: pkg.entry_point || "index.ts"
+      }, null, 2), "utf-8");
+      restored++;
+    } catch {
+    }
+  }
+  if (restored > 0) {
+    spinner.succeed(`${restored} pakke(r) gjenopprettet: ${missing.filter((_, i) => i < restored).map((s) => `@kode/${s}`).join(", ")}`);
+  } else {
+    spinner.info("Ingen pakker \xE5 gjenopprette");
+  }
+}
+
+export {
+  pkgAddCommand,
+  pkgRemoveCommand,
+  pkgPublishCommand,
+  pkgListCommand,
+  pkgInfoCommand,
+  pkgUpdateCommand,
+  restorePackages
+};

package/dist/chunk-R4KWWTS4.js

@@ -0,0 +1,75 @@
+import {
+  createApiClient,
+  findProjectRoot,
+  getProjectConfig,
+  getScriptsDir
+} from "./chunk-TLLGB46I.js";
+
+// src/commands/types.ts
+import chalk from "chalk";
+import ora from "ora";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+async function generateCmsTypes(options) {
+  const silent = options?.silent ?? false;
+  const spinner = silent ? null : ora("Henter CMS-typer fra Webflow...").start();
+  try {
+    const projectRoot = findProjectRoot();
+    if (!projectRoot) {
+      spinner?.fail("Ikke i et Kode-prosjekt");
+      return false;
+    }
+    const config = getProjectConfig(projectRoot);
+    if (!config) {
+      spinner?.fail("Kunne ikke lese prosjektkonfigurasjon");
+      return false;
+    }
+    const api = createApiClient(config);
+    let result;
+    try {
+      result = await api.getCmsTypes(config.siteId);
+    } catch (err) {
+      if (err.message?.includes("Webflow credentials not configured")) {
+        spinner?.info("Webflow ikke konfigurert \u2014 hopper over CMS-typer");
+        return false;
+      }
+      throw err;
+    }
+    if (!result.collections || result.collections.length === 0) {
+      spinner?.info("Ingen CMS-samlinger funnet");
+      return false;
+    }
+    const scriptsDir = getScriptsDir(projectRoot, config);
+    const typesDir = join(scriptsDir, "types");
+    if (!existsSync(typesDir)) {
+      mkdirSync(typesDir, { recursive: true });
+    }
+    writeFileSync(join(typesDir, "cms.d.ts"), result.typescript, "utf-8");
+    if (!silent) {
+      spinner?.succeed(
+        `CMS-typer generert: ${result.collections.length} samlinger \u2192 ${chalk.cyan("types/cms.d.ts")}`
+      );
+      for (const col of result.collections) {
+        console.log(
+          `  ${chalk.dim("\u2022")} ${col.displayName} ${chalk.dim(`(${col.fieldCount} felt)`)}`
+        );
+      }
+    } else {
+      spinner?.stop();
+    }
+    return true;
+  } catch (err) {
+    if (!silent) {
+      spinner?.fail(`Kunne ikke generere CMS-typer: ${err.message}`);
+    }
+    return false;
+  }
+}
+async function typesCommand() {
+  await generateCmsTypes({ silent: false });
+}
+
+export {
+  generateCmsTypes,
+  typesCommand
+};