@decantr/cli 1.0.0-beta.2

package/dist/index.js

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { validateEssence, evaluateGuard } from "@decantr/essence-spec";
+import { createResolver, createRegistryClient } from "@decantr/registry";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
+var CYAN = "\x1B[36m";
+var YELLOW = "\x1B[33m";
+function heading(text) {
+  return `
+${BOLD}${text}${RESET}
+`;
+}
+function success(text) {
+  return `${GREEN}${text}${RESET}`;
+}
+function error(text) {
+  return `${RED}${text}${RESET}`;
+}
+function dim(text) {
+  return `${DIM}${text}${RESET}`;
+}
+function cyan(text) {
+  return `${CYAN}${text}${RESET}`;
+}
+function getContentRoot() {
+  const bundled = join(import.meta.dirname, "..", "..", "..", "content");
+  return process.env.DECANTR_CONTENT_ROOT || bundled;
+}
+function getResolver() {
+  return createResolver({ contentRoot: getContentRoot() });
+}
+async function cmdSearch(query, type) {
+  const client = createRegistryClient();
+  const results = await client.search(query, type);
+  if (results.length === 0) {
+    console.log(dim(`No results for "${query}"`));
+    return;
+  }
+  console.log(heading(`${results.length} result(s) for "${query}"`));
+  for (const r of results) {
+    console.log(`  ${cyan(r.type.padEnd(12))} ${BOLD}${r.id}${RESET}`);
+    console.log(`  ${dim(r.description || "")}`);
+    console.log("");
+  }
+}
+async function cmdGet(type, id) {
+  const validTypes = ["pattern", "archetype", "recipe", "theme", "blueprint"];
+  if (!validTypes.includes(type)) {
+    console.error(error(`Invalid type "${type}". Must be one of: ${validTypes.join(", ")}`));
+    process.exitCode = 1;
+    return;
+  }
+  const resolver = getResolver();
+  const result = await resolver.resolve(type, id);
+  if (!result) {
+    console.error(error(`${type} "${id}" not found.`));
+    process.exitCode = 1;
+    return;
+  }
+  console.log(JSON.stringify(result.item, null, 2));
+}
+async function cmdValidate(path) {
+  const essencePath = path || join(process.cwd(), "decantr.essence.json");
+  let raw;
+  try {
+    raw = readFileSync(essencePath, "utf-8");
+  } catch {
+    console.error(error(`Could not read ${essencePath}`));
+    process.exitCode = 1;
+    return;
+  }
+  let essence;
+  try {
+    essence = JSON.parse(raw);
+  } catch (e) {
+    console.error(error(`Invalid JSON: ${e.message}`));
+    process.exitCode = 1;
+    return;
+  }
+  const result = validateEssence(essence);
+  if (result.valid) {
+    console.log(success("Essence is valid."));
+  } else {
+    console.error(error("Validation failed:"));
+    for (const err of result.errors) {
+      console.error(`  ${RED}${err}${RESET}`);
+    }
+    process.exitCode = 1;
+  }
+  try {
+    const violations = evaluateGuard(essence, {});
+    if (violations.length > 0) {
+      console.log(heading("Guard violations:"));
+      for (const v of violations) {
+        const vr = v;
+        console.log(`  ${YELLOW}[${vr.rule}]${RESET} ${vr.message}`);
+      }
+    } else if (result.valid) {
+      console.log(success("No guard violations."));
+    }
+  } catch {
+  }
+}
+async function cmdList(type) {
+  const validTypes = ["patterns", "archetypes", "recipes", "themes", "blueprints"];
+  if (!validTypes.includes(type)) {
+    console.error(error(`Invalid type "${type}". Must be one of: ${validTypes.join(", ")}`));
+    process.exitCode = 1;
+    return;
+  }
+  const { readdirSync } = await import("fs");
+  const dir = join(getContentRoot(), type);
+  try {
+    const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+    console.log(heading(`${files.length} ${type}`));
+    for (const f of files) {
+      const data = JSON.parse(readFileSync(join(dir, f), "utf-8"));
+      console.log(`  ${cyan(data.id || f.replace(".json", ""))}  ${dim(data.description || data.name || "")}`);
+    }
+  } catch {
+    const coreDir = join(getContentRoot(), "core", type);
+    try {
+      const files = readdirSync(coreDir).filter((f) => f.endsWith(".json"));
+      console.log(heading(`${files.length} ${type} (core)`));
+      for (const f of files) {
+        const data = JSON.parse(readFileSync(join(coreDir, f), "utf-8"));
+        console.log(`  ${cyan(data.id || f.replace(".json", ""))}  ${dim(data.description || data.name || "")}`);
+      }
+    } catch {
+      console.log(dim(`No ${type} found.`));
+    }
+  }
+}
+function cmdHelp() {
+  console.log(`
+${BOLD}decantr${RESET} \u2014 Design intelligence for AI-generated UI
+
+${BOLD}Usage:${RESET}
+  decantr search <query> [--type pattern|archetype|recipe|theme]
+  decantr get <type> <id>
+  decantr list <type>
+  decantr validate [path]
+  decantr help
+
+${BOLD}Commands:${RESET}
+  ${cyan("search")}    Search the registry for patterns, archetypes, recipes, themes
+  ${cyan("get")}       Get full details of a registry item as JSON
+  ${cyan("list")}      List all items of a type (patterns, archetypes, recipes, themes, blueprints)
+  ${cyan("validate")}  Validate a decantr.essence.json file against the schema and guard rules
+  ${cyan("help")}      Show this help message
+
+${BOLD}Examples:${RESET}
+  decantr search dashboard
+  decantr search kpi --type pattern
+  decantr get pattern kpi-grid
+  decantr get recipe luminarum
+  decantr get theme luminarum
+  decantr list patterns
+  decantr list themes
+  decantr validate
+  decantr validate ./my-project/decantr.essence.json
+`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  if (!command || command === "help" || command === "--help" || command === "-h") {
+    cmdHelp();
+    return;
+  }
+  switch (command) {
+    case "search": {
+      const query = args[1];
+      if (!query) {
+        console.error(error("Usage: decantr search <query> [--type <type>]"));
+        process.exitCode = 1;
+        return;
+      }
+      const typeIdx = args.indexOf("--type");
+      const type = typeIdx !== -1 ? args[typeIdx + 1] : void 0;
+      await cmdSearch(query, type);
+      break;
+    }
+    case "get": {
+      const type = args[1];
+      const id = args[2];
+      if (!type || !id) {
+        console.error(error("Usage: decantr get <type> <id>"));
+        process.exitCode = 1;
+        return;
+      }
+      await cmdGet(type, id);
+      break;
+    }
+    case "list": {
+      const type = args[1];
+      if (!type) {
+        console.error(error("Usage: decantr list <type>"));
+        process.exitCode = 1;
+        return;
+      }
+      await cmdList(type);
+      break;
+    }
+    case "validate": {
+      await cmdValidate(args[1]);
+      break;
+    }
+    default:
+      console.error(error(`Unknown command: ${command}`));
+      cmdHelp();
+      process.exitCode = 1;
+  }
+}
+main().catch((e) => {
+  console.error(error(e.message));
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@decantr/cli",
+  "version": "1.0.0-beta.2",
+  "description": "Decantr CLI — search the registry, validate essence files, and access design intelligence from the terminal",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/decantr-ai/decantr.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://decantr.ai",
+  "type": "module",
+  "bin": {
+    "decantr": "./dist/index.js"
+  },
+  "main": "dist/index.js",
+  "files": ["dist"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@decantr/essence-spec": "workspace:*",
+    "@decantr/registry": "workspace:*"
+  }
+}