@cloudraker/reki 2.6.1

package/dist/command-line/commands/add.js

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+
+// src/command-line/commands/add.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname, join as join2, resolve, relative, isAbsolute } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/command-line/utils/config.ts
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var DEFAULT_CONFIG = {
+  blocksDir: "src/components/reki",
+  version: "1.0.0"
+};
+function readConfig(projectRoot = process.cwd()) {
+  const configPath = join(projectRoot, "reki.json");
+  if (!existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const config = JSON.parse(content);
+    return {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to parse reki.json: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+}
+
+// src/command-line/utils/transformer.ts
+function parseImports(content) {
+  const importRegex = /import\s+(type\s+)?{([^}]+)}\s+from\s+["']([^"']+)["'];?/g;
+  const imports = [];
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    imports.push({
+      fullMatch: match[0],
+      imports: match[2],
+      path: match[3],
+      startIndex: match.index,
+      endIndex: match.index + match[0].length,
+      isTypeOnlyImport: match[1] !== void 0
+    });
+  }
+  return imports;
+}
+function shouldTransformToReki(path) {
+  if (!path.startsWith("../")) {
+    return false;
+  }
+  return path.includes("/components/") || path.includes("/utils/");
+}
+function parseImportItems(imports, isTypeOnlyImport) {
+  const items = imports.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+  const valueImports = [];
+  const typeImports = [];
+  for (const item of items) {
+    if (isTypeOnlyImport || item.startsWith("type ")) {
+      const typeName = item.startsWith("type ") ? item.slice(5).trim() : item;
+      typeImports.push(typeName);
+    } else {
+      valueImports.push(item);
+    }
+  }
+  return { valueImports, typeImports };
+}
+function buildConsolidatedImport(valueImports, typeImports) {
+  const parts = [];
+  for (const item of valueImports) {
+    parts.push(item);
+  }
+  for (const item of typeImports) {
+    parts.push(`type ${item}`);
+  }
+  return `import { ${parts.join(", ")} } from "@cloudraker/reki";`;
+}
+function transformImports(content) {
+  const parsedImports = parseImports(content);
+  const rekiImports = [];
+  const nonRekiImports = [];
+  for (const imp of parsedImports) {
+    if (shouldTransformToReki(imp.path)) {
+      rekiImports.push(imp);
+    } else {
+      nonRekiImports.push(imp);
+    }
+  }
+  if (rekiImports.length === 0) {
+    return content;
+  }
+  const allValueImports = [];
+  const allTypeImports = [];
+  for (const imp of rekiImports) {
+    const { valueImports, typeImports } = parseImportItems(
+      imp.imports,
+      imp.isTypeOnlyImport
+    );
+    allValueImports.push(...valueImports);
+    allTypeImports.push(...typeImports);
+  }
+  const consolidatedImport = buildConsolidatedImport(
+    allValueImports,
+    allTypeImports
+  );
+  let result = content;
+  const sortedRekiImports = [...rekiImports].sort(
+    (a, b) => b.startIndex - a.startIndex
+  );
+  for (let i = 0; i < sortedRekiImports.length; i++) {
+    const imp = sortedRekiImports[i];
+    if (i === sortedRekiImports.length - 1) {
+      result = result.slice(0, imp.startIndex) + consolidatedImport + result.slice(imp.endIndex);
+    } else {
+      let startIndex = imp.startIndex;
+      let endIndex = imp.endIndex;
+      if (startIndex > 0 && result[startIndex - 1] === "\n") {
+        startIndex--;
+      }
+      result = result.slice(0, startIndex) + result.slice(endIndex);
+    }
+  }
+  return result;
+}
+
+// src/command-line/commands/add.ts
+import { createInterface } from "node:readline/promises";
+function getRegistryPath() {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const possiblePaths = [
+    join2(__dirname, "..", "..", "ai", "component-registry.json"),
+    join2(__dirname, "..", "ai", "component-registry.json"),
+    join2(__dirname, "ai", "component-registry.json")
+  ];
+  for (const path of possiblePaths) {
+    if (existsSync2(path)) {
+      return path;
+    }
+  }
+  throw new Error(
+    "component-registry.json not found. Please regenerate with: pnpm codegen:registry"
+  );
+}
+function getBlocksSourcePath() {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const possiblePaths = [
+    join2(__dirname, "..", "..", "blocks-source"),
+    join2(__dirname, "..", "blocks-source"),
+    join2(__dirname, "blocks-source"),
+    // Fallback to old location for backwards compatibility during development
+    join2(__dirname, "..", "..", "src", "blocks"),
+    join2(__dirname, "..", "src", "blocks"),
+    join2(__dirname, "src", "blocks")
+  ];
+  for (const path of possiblePaths) {
+    if (existsSync2(path)) {
+      return path;
+    }
+  }
+  throw new Error(
+    "Blocks source directory not found. The package may be corrupted."
+  );
+}
+function loadRegistry() {
+  const registryPath = getRegistryPath();
+  const content = readFileSync2(registryPath, "utf-8");
+  return JSON.parse(content);
+}
+async function confirm(message) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const answer = await rl.question(`${message} (y/n): `);
+  rl.close();
+  return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+}
+async function add(blockName) {
+  if (!blockName) {
+    console.error("Error: Block name is required.");
+    console.log("\nUsage: reki add <block-name>");
+    console.log("\nRun 'reki blocks' to see available blocks.");
+    process.exit(1);
+  }
+  const config = readConfig();
+  if (!config) {
+    console.error(
+      "Error: reki.json not found. Run 'reki init' first to initialize the configuration."
+    );
+    process.exit(1);
+  }
+  let registry;
+  try {
+    registry = loadRegistry();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Component registry not found. Run `pnpm codegen:registry` first.";
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+  const block = registry.blocks?.[blockName];
+  if (!block) {
+    console.error(`Error: Block '${blockName}' not found.`);
+    console.log("\nRun 'reki blocks' to see available blocks.");
+    process.exit(1);
+  }
+  let blocksSourcePath;
+  try {
+    blocksSourcePath = getBlocksSourcePath();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Blocks source directory not found.";
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+  const projectRoot = process.cwd();
+  const targetDir = join2(projectRoot, config.blocksDir);
+  if (!existsSync2(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+    console.log(`\u{1F4C1} Created directory: ${config.blocksDir}`);
+  }
+  const blockExists = block.files.some((file) => {
+    const targetPath = join2(targetDir, file);
+    return existsSync2(targetPath);
+  });
+  if (blockExists) {
+    console.log(
+      `\u26A0\uFE0F  Block '${blockName}' already exists in ${config.blocksDir}`
+    );
+    const shouldOverwrite = await confirm("Do you want to overwrite it?");
+    if (!shouldOverwrite) {
+      console.log("Installation cancelled.");
+      return;
+    }
+  }
+  console.log(`\u{1F4E6} Installing block: ${blockName}`);
+  for (const file of block.files) {
+    const sourcePath = resolve(blocksSourcePath, file);
+    const targetPath = resolve(targetDir, file);
+    const relativeSource = relative(blocksSourcePath, sourcePath);
+    if (relativeSource.startsWith("..") || relativeSource.startsWith("/") || isAbsolute(relativeSource)) {
+      console.error(`Error: Invalid source path for file: ${file}`);
+      process.exit(1);
+    }
+    const relativeTarget = relative(targetDir, targetPath);
+    if (relativeTarget.startsWith("..") || relativeTarget.startsWith("/") || isAbsolute(relativeTarget)) {
+      console.error(`Error: Invalid target path for file: ${file}`);
+      process.exit(1);
+    }
+    const targetSubdir = dirname(targetPath);
+    if (!existsSync2(targetSubdir)) {
+      mkdirSync(targetSubdir, { recursive: true });
+    }
+    const content = readFileSync2(sourcePath, "utf-8");
+    const transformed = transformImports(content);
+    writeFileSync2(targetPath, transformed, "utf-8");
+    console.log(`  \u2705 ${file}`);
+  }
+  if (block.dependencies.length > 0) {
+    console.log(`
+\u{1F4DA} This block depends on the following Reki components:
+`);
+    for (const dep of block.dependencies) {
+      console.log(`  - ${dep} (from @cloudraker/reki)`);
+    }
+    console.log("\nMake sure @cloudraker/reki is installed in your project:");
+    console.log("  pnpm add @cloudraker/reki");
+  }
+  console.log(`
+\u{1F389} Successfully installed ${blockName}!`);
+  console.log(`
+You can now import it in your project:
+`);
+  const blockFile = block.files[0].replace(/\.tsx?$/, "");
+  const importPath = join2(config.blocksDir, blockFile).replace(/\\/g, "/");
+  console.log(`  import { ${blockName} } from "${importPath}";`);
+}
+export {
+  add
+};

package/dist/command-line/commands/ai.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+// src/command-line/commands/ai.ts
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function ai() {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const usagePath = join(__dirname, "..", "..", "ai", "USAGE.md");
+  try {
+    const content = readFileSync(usagePath, "utf-8");
+    console.log(content);
+  } catch {
+    console.error(
+      "Could not read ai/USAGE.md. Make sure you are running this from an installed @cloudraker/reki package."
+    );
+    process.exit(1);
+  }
+}
+export {
+  ai
+};

package/dist/command-line/commands/blocks.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+// src/command-line/commands/blocks.ts
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function getRegistryPath() {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  return join(__dirname, "..", "..", "ai", "component-registry.json");
+}
+function loadRegistry() {
+  const registryPath = getRegistryPath();
+  const content = readFileSync(registryPath, "utf-8");
+  return JSON.parse(content);
+}
+function blocks() {
+  try {
+    const registry = loadRegistry();
+    if (!registry.blocks || Object.keys(registry.blocks).length === 0) {
+      console.log("No blocks available.");
+      return;
+    }
+    const blockList = Object.values(registry.blocks);
+    const byCategory = /* @__PURE__ */ new Map();
+    for (const block of blockList) {
+      const category = block.category || "Other";
+      if (!byCategory.has(category)) {
+        byCategory.set(category, []);
+      }
+      byCategory.get(category).push(block);
+    }
+    const sortedCategories = [...byCategory.keys()].sort();
+    console.log(`Reki Blocks (${blockList.length} total)
+`);
+    for (const category of sortedCategories) {
+      const categoryBlocks = [...byCategory.get(category)].sort(
+        (a, b) => a.name.localeCompare(b.name)
+      );
+      console.log(`${category}:`);
+      for (const block of categoryBlocks) {
+        console.log(`  ${block.name} - ${block.description}`);
+      }
+      console.log();
+    }
+    console.log("To install a block, run:");
+    console.log("  reki add <block-name>\n");
+    console.log("Example:");
+    console.log("  reki add PageHeader");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      console.error(
+        "Error: Component registry not found. Run `pnpm codegen:registry` first."
+      );
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+export {
+  blocks
+};

package/dist/command-line/commands/doc.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+
+// src/command-line/commands/doc.ts
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function getRegistryPath() {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  return join(__dirname, "..", "..", "ai", "component-registry.json");
+}
+function loadRegistry() {
+  const registryPath = getRegistryPath();
+  const content = readFileSync(registryPath, "utf-8");
+  return JSON.parse(content);
+}
+function findComponent(registry, name) {
+  const lowerName = name.toLowerCase();
+  for (const [key, component] of Object.entries(registry.components)) {
+    if (key.toLowerCase() === lowerName) {
+      return component;
+    }
+  }
+  return null;
+}
+function findSimilar(registry, name) {
+  const lowerName = name.toLowerCase();
+  const componentNames = Object.keys(registry.components);
+  return componentNames.filter(
+    (n) => n.toLowerCase().includes(lowerName) || lowerName.includes(n.toLowerCase())
+  ).slice(0, 5);
+}
+function formatProp(name, prop) {
+  const parts = [];
+  let typeStr = prop.type;
+  if (prop.values && prop.values.length > 0) {
+    typeStr = prop.values.map((v) => `"${v}"`).join(" | ");
+  }
+  const required = prop.required === true || prop.optional === false;
+  const requiredStr = required ? "(required)" : "";
+  const defaultStr = prop.default ? `[default: ${prop.default}]` : "";
+  parts.push(`  ${name}: ${typeStr} ${requiredStr} ${defaultStr}`.trim());
+  if (prop.description) {
+    parts.push(`    ${prop.description}`);
+  }
+  if (prop.descriptions && Object.keys(prop.descriptions).length > 0) {
+    for (const [value, desc] of Object.entries(prop.descriptions)) {
+      parts.push(`    - "${value}": ${desc}`);
+    }
+  }
+  return parts.join("\n");
+}
+function formatComponentDoc(component) {
+  const lines = [];
+  lines.push(`# ${component.name}
+`);
+  lines.push(`${component.description}
+`);
+  lines.push(
+    `**Import:** \`import { ${component.name} } from "${component.importPath}";\`
+`
+  );
+  lines.push(`**Category:** ${component.category}
+`);
+  const propEntries = Object.entries(component.props);
+  if (propEntries.length > 0) {
+    lines.push("## Props\n");
+    for (const [propName, propInfo] of propEntries) {
+      lines.push(formatProp(propName, propInfo));
+      lines.push("");
+    }
+  }
+  if (component.subComponents) {
+    lines.push("## Sub-Components\n");
+    for (const [subName, subInfo] of Object.entries(component.subComponents)) {
+      lines.push(`### ${component.name}.${subName}`);
+      if (subInfo.description) {
+        lines.push(subInfo.description);
+      }
+      if (subInfo.renderElement) {
+        lines.push(`Renders: ${subInfo.renderElement}`);
+      }
+      if (subInfo.props) {
+        lines.push("Props:");
+        for (const [propName, propInfo] of Object.entries(subInfo.props)) {
+          const required = propInfo.required ? "(required)" : "";
+          lines.push(`  - ${propName}: ${propInfo.type} ${required}`);
+        }
+      }
+      lines.push("");
+    }
+  }
+  if (component.examples && component.examples.length > 0) {
+    lines.push("## Examples\n");
+    for (const example of component.examples.slice(0, 3)) {
+      lines.push("```tsx");
+      lines.push(example);
+      lines.push("```\n");
+    }
+    if (component.examples.length > 3) {
+      lines.push(
+        `(${component.examples.length - 3} more examples available in Storybook)`
+      );
+    }
+  }
+  if (component.colors && component.colors.length > 0) {
+    lines.push("\n## Semantic Tokens Used\n");
+    lines.push(component.colors.join(", "));
+  }
+  return lines.join("\n");
+}
+function docs() {
+  try {
+    const registry = loadRegistry();
+    const components = Object.values(registry.components);
+    console.log(`# Reki Component Documentation
+`);
+    console.log(`${components.length} components available
+`);
+    console.log("---\n");
+    for (const component of components) {
+      console.log(formatComponentDoc(component));
+      console.log("\n---\n");
+    }
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      console.error(
+        "Error: Component registry not found. Run `pnpm codegen:registry` first."
+      );
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+function doc(componentName) {
+  if (!componentName) {
+    docs();
+    return;
+  }
+  try {
+    const registry = loadRegistry();
+    const component = findComponent(registry, componentName);
+    if (!component) {
+      const similar = findSimilar(registry, componentName);
+      console.error(`Component "${componentName}" not found.`);
+      if (similar.length > 0) {
+        console.error(`
+Did you mean: ${similar.join(", ")}?`);
+      }
+      console.error(`
+Run "reki ls" to see all available components.`);
+      process.exit(1);
+    }
+    console.log(formatComponentDoc(component));
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      console.error(
+        "Error: Component registry not found. Run `pnpm codegen:registry` first."
+      );
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+export {
+  doc,
+  docs
+};

package/dist/command-line/commands/init.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+// src/command-line/commands/init.ts
+import { createInterface } from "node:readline/promises";
+
+// src/command-line/utils/config.ts
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var DEFAULT_CONFIG = {
+  blocksDir: "src/components/reki",
+  version: "1.0.0"
+};
+function writeConfig(config, projectRoot = process.cwd()) {
+  const configPath = join(projectRoot, "reki.json");
+  const fullConfig = {
+    ...DEFAULT_CONFIG,
+    ...config
+  };
+  try {
+    const content = JSON.stringify(fullConfig, null, 2) + "\n";
+    writeFileSync(configPath, content, "utf-8");
+  } catch (error) {
+    throw new Error(
+      `Failed to write reki.json: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+}
+function configExists(projectRoot = process.cwd()) {
+  const configPath = join(projectRoot, "reki.json");
+  return existsSync(configPath);
+}
+
+// src/command-line/commands/init.ts
+async function prompt(question, defaultValue) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const suffix = defaultValue ? ` (${defaultValue})` : "";
+    const answer = await rl.question(`${question}${suffix}: `);
+    return answer.trim() || defaultValue || "";
+  } finally {
+    rl.close();
+  }
+}
+async function confirm(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = await rl.question(`${question} (y/n): `);
+    return answer.trim().toLowerCase() === "y";
+  } finally {
+    rl.close();
+  }
+}
+async function init() {
+  try {
+    const projectRoot = process.cwd();
+    if (configExists(projectRoot)) {
+      console.log("\u26A0\uFE0F  reki.json already exists in this directory.");
+      const shouldOverwrite = await confirm("Do you want to overwrite it?");
+      if (!shouldOverwrite) {
+        console.log("Initialization cancelled.");
+        process.exit(0);
+      }
+    }
+    console.log("\n\u{1F680} Initializing Reki configuration...\n");
+    const blocksDir = await prompt(
+      "Where should blocks be installed?",
+      DEFAULT_CONFIG.blocksDir
+    );
+    const config = {
+      blocksDir: blocksDir || DEFAULT_CONFIG.blocksDir,
+      version: DEFAULT_CONFIG.version
+    };
+    writeConfig(config, projectRoot);
+    console.log("\n\u2705 Created reki.json with the following configuration:");
+    console.log(`   \u{1F4C1} Blocks directory: ${config.blocksDir}`);
+    console.log("\nNext steps:");
+    console.log("  \u2022 Run `reki blocks` to see available blocks");
+    console.log("  \u2022 Run `reki add <block>` to install a block");
+  } catch (error) {
+    console.error("Error initializing configuration:", error);
+    process.exit(1);
+  }
+}
+export {
+  confirm,
+  init,
+  prompt
+};

package/dist/command-line/commands/ls.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+// src/command-line/commands/ls.ts
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+function getRegistryPath() {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  return join(__dirname, "..", "..", "ai", "component-registry.json");
+}
+function loadRegistry() {
+  const registryPath = getRegistryPath();
+  const content = readFileSync(registryPath, "utf-8");
+  return JSON.parse(content);
+}
+function ls() {
+  try {
+    const registry = loadRegistry();
+    const components = Object.values(registry.components);
+    const byCategory = /* @__PURE__ */ new Map();
+    for (const component of components) {
+      const category = component.category || "Other";
+      if (!byCategory.has(category)) {
+        byCategory.set(category, []);
+      }
+      byCategory.get(category).push(component);
+    }
+    const sortedCategories = [...byCategory.keys()].sort();
+    console.log(`Reki Components (${components.length} total)
+`);
+    for (const category of sortedCategories) {
+      const categoryComponents = [...byCategory.get(category)].sort(
+        (a, b) => a.name.localeCompare(b.name)
+      );
+      console.log(`${category}:`);
+      for (const component of categoryComponents) {
+        console.log(`  ${component.name} - ${component.description}`);
+      }
+      console.log();
+    }
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      console.error(
+        "Error: Component registry not found. Run `pnpm codegen:registry` first."
+      );
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+export {
+  ls
+};

package/dist/components/autocomplete.js

@@ -0,0 +1,9 @@
+"use client";
+import { A as e, R as t, a as E, b as T } from "../chunks/autocomplete-f4vetako14h2aqsw.js";
+export {
+  e as Autocomplete,
+  t as REKI_AUTOCOMPLETE_DEFAULT_VARIANTS,
+  E as REKI_AUTOCOMPLETE_VARIANTS,
+  T as autocompleteVariants
+};
+//# sourceMappingURL=autocomplete.js.map

package/dist/components/autocomplete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autocomplete.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}