@decantr/cli 1.0.0-beta.7 → 1.0.0

package/dist/chunk-PDX44BCA.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+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-PWTUBGGJ.js

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+
+// src/registry.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var DEFAULT_API_URL = "https://decantr-registry.fly.dev/v1";
+function getLocalBundledRoot() {
+  return join(__dirname, "bundled");
+}
+function loadFromBundledLocal(contentType, id) {
+  const bundledRoot = getLocalBundledRoot();
+  if (id) {
+    const filePath = join(bundledRoot, contentType, `${id}.json`);
+    if (existsSync(filePath)) {
+      try {
+        const data = JSON.parse(readFileSync(filePath, "utf-8"));
+        return { data, source: { type: "bundled" } };
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  const dir = join(bundledRoot, contentType);
+  if (!existsSync(dir)) return null;
+  try {
+    const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+    const items = files.map((f) => {
+      const content = JSON.parse(readFileSync(join(dir, f), "utf-8"));
+      return { id: content.id || f.replace(".json", ""), ...content };
+    });
+    return {
+      data: { items, total: items.length },
+      source: { type: "bundled" }
+    };
+  } catch {
+    return null;
+  }
+}
+async function fetchWithTimeout(url, timeoutMs = 5e3) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { signal: controller.signal });
+    return response;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function tryApi(endpoint, apiUrl = DEFAULT_API_URL) {
+  try {
+    const url = `${apiUrl}/${endpoint}`;
+    const response = await fetchWithTimeout(url);
+    if (!response.ok) return null;
+    const data = await response.json();
+    return {
+      data,
+      source: { type: "api", url: apiUrl }
+    };
+  } catch {
+    return null;
+  }
+}
+function loadFromCache(cacheDir, contentType, id) {
+  const cachePath = id ? join(cacheDir, contentType, `${id}.json`) : join(cacheDir, contentType, "index.json");
+  if (!existsSync(cachePath)) return null;
+  try {
+    const data = JSON.parse(readFileSync(cachePath, "utf-8"));
+    return {
+      data,
+      source: { type: "cache" }
+    };
+  } catch {
+    return null;
+  }
+}
+function saveToCache(cacheDir, contentType, id, data) {
+  const dir = join(cacheDir, contentType);
+  mkdirSync(dir, { recursive: true });
+  const cachePath = id ? join(dir, `${id}.json`) : join(dir, "index.json");
+  writeFileSync(cachePath, JSON.stringify(data, null, 2));
+}
+var RegistryClient = class {
+  cacheDir;
+  apiUrl;
+  offline;
+  projectRoot;
+  constructor(options = {}) {
+    this.projectRoot = options.projectRoot || process.cwd();
+    this.cacheDir = options.cacheDir || join(this.projectRoot, ".decantr", "cache");
+    this.apiUrl = options.apiUrl || DEFAULT_API_URL;
+    this.offline = options.offline || false;
+  }
+  /**
+   * Load content from .decantr/custom/{contentType}/{id}.json
+   */
+  loadCustomContent(contentType, id) {
+    const customPath = join(
+      this.projectRoot,
+      ".decantr",
+      "custom",
+      contentType,
+      `${id}.json`
+    );
+    if (!existsSync(customPath)) {
+      return null;
+    }
+    try {
+      const data = JSON.parse(readFileSync(customPath, "utf-8"));
+      return {
+        data,
+        source: { type: "custom", path: customPath }
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Fetch archetypes list.
+   */
+  async fetchArchetypes() {
+    if (!this.offline) {
+      const apiResult = await tryApi("archetypes", this.apiUrl);
+      if (apiResult) {
+        saveToCache(this.cacheDir, "archetypes", null, apiResult.data);
+        return apiResult;
+      }
+    }
+    const cacheResult = loadFromCache(
+      this.cacheDir,
+      "archetypes"
+    );
+    if (cacheResult) return cacheResult;
+    const bundledResult = loadFromBundledLocal("archetypes");
+    if (bundledResult) return bundledResult;
+    return {
+      data: { items: [], total: 0 },
+      source: { type: "bundled" }
+    };
+  }
+  /**
+   * Fetch a single archetype.
+   */
+  async fetchArchetype(id) {
+    if (!this.offline) {
+      const apiResult = await tryApi(`archetypes/${id}`, this.apiUrl);
+      if (apiResult) {
+        saveToCache(this.cacheDir, "archetypes", id, apiResult.data);
+        return apiResult;
+      }
+    }
+    const cacheResult = loadFromCache(this.cacheDir, "archetypes", id);
+    if (cacheResult) return cacheResult;
+    return loadFromBundledLocal("archetypes", id);
+  }
+  /**
+   * Fetch blueprints list.
+   */
+  async fetchBlueprints() {
+    if (!this.offline) {
+      const apiResult = await tryApi("blueprints", this.apiUrl);
+      if (apiResult) {
+        saveToCache(this.cacheDir, "blueprints", null, apiResult.data);
+        return apiResult;
+      }
+    }
+    const cacheResult = loadFromCache(
+      this.cacheDir,
+      "blueprints"
+    );
+    if (cacheResult) return cacheResult;
+    const bundledResult = loadFromBundledLocal("blueprints");
+    if (bundledResult) return bundledResult;
+    return {
+      data: { items: [], total: 0 },
+      source: { type: "bundled" }
+    };
+  }
+  /**
+   * Fetch a single blueprint.
+   */
+  async fetchBlueprint(id) {
+    if (!this.offline) {
+      const apiResult = await tryApi(`blueprints/${id}`, this.apiUrl);
+      if (apiResult) {
+        saveToCache(this.cacheDir, "blueprints", id, apiResult.data);
+        return apiResult;
+      }
+    }
+    const cacheResult = loadFromCache(this.cacheDir, "blueprints", id);
+    if (cacheResult) return cacheResult;
+    const bundledResult = loadFromBundledLocal("blueprints", id);
+    if (bundledResult) return bundledResult;
+    return loadFromBundledLocal("blueprints", id);
+  }
+  /**
+   * Fetch themes list.
+   */
+  async fetchThemes() {
+    if (!this.offline) {
+      const apiResult = await tryApi("themes", this.apiUrl);
+      if (apiResult) {
+        saveToCache(this.cacheDir, "themes", null, apiResult.data);
+        return apiResult;
+      }
+    }
+    const cacheResult = loadFromCache(
+      this.cacheDir,
+      "themes"
+    );
+    if (cacheResult) return cacheResult;
+    const bundledResult = loadFromBundledLocal("themes");
+    if (bundledResult) return bundledResult;
+    return {
+      data: { items: [], total: 0 },
+      source: { type: "bundled" }
+    };
+  }
+  /**
+   * Fetch a single theme.
+   */
+  async fetchTheme(id) {
+    if (id.startsWith("custom:")) {
+      return this.loadCustomContent("themes", id.slice(7));
+    }
+    if (!this.offline) {
+      const apiResult = await tryApi(`themes/${id}`, this.apiUrl);
+      if (apiResult) {
+        saveToCache(this.cacheDir, "themes", id, apiResult.data);
+        return apiResult;
+      }
+    }
+    const cacheResult = loadFromCache(this.cacheDir, "themes", id);
+    if (cacheResult) return cacheResult;
+    const bundledResult = loadFromBundledLocal("themes", id);
+    if (bundledResult) return bundledResult;
+    return loadFromBundledLocal("themes", id);
+  }
+  /**
+   * Fetch patterns list.
+   */
+  async fetchPatterns() {
+    if (!this.offline) {
+      const apiResult = await tryApi("patterns", this.apiUrl);
+      if (apiResult) {
+        saveToCache(this.cacheDir, "patterns", null, apiResult.data);
+        return apiResult;
+      }
+    }
+    const cacheResult = loadFromCache(
+      this.cacheDir,
+      "patterns"
+    );
+    if (cacheResult) return cacheResult;
+    const bundledResult = loadFromBundledLocal("patterns");
+    if (bundledResult) return bundledResult;
+    return {
+      data: { items: [], total: 0 },
+      source: { type: "bundled" }
+    };
+  }
+  /**
+   * Fetch shells list.
+   */
+  async fetchShells() {
+    if (!this.offline) {
+      const apiResult = await tryApi("shells", this.apiUrl);
+      if (apiResult) {
+        saveToCache(this.cacheDir, "shells", null, apiResult.data);
+        return apiResult;
+      }
+    }
+    const cacheResult = loadFromCache(
+      this.cacheDir,
+      "shells"
+    );
+    if (cacheResult) return cacheResult;
+    const bundledResult = loadFromBundledLocal("shells");
+    if (bundledResult) return bundledResult;
+    const localBundled = loadFromBundledLocal("shells");
+    if (localBundled) return localBundled;
+    return {
+      data: { items: [], total: 0 },
+      source: { type: "bundled" }
+    };
+  }
+  /**
+   * Fetch a single shell.
+   * Note: API only has /shells list endpoint, not /shells/{id}, so we fetch all and filter.
+   */
+  async fetchShell(id) {
+    if (!this.offline) {
+      const apiResult = await tryApi("shells", this.apiUrl);
+      if (apiResult) {
+        const shell = apiResult.data.items.find((s) => s.id === id);
+        if (shell) {
+          saveToCache(this.cacheDir, "shells", id, shell);
+          return { data: shell, source: apiResult.source };
+        }
+      }
+    }
+    const cacheResult = loadFromCache(this.cacheDir, "shells", id);
+    if (cacheResult) return cacheResult;
+    const bundledResult = loadFromBundledLocal("shells", id);
+    if (bundledResult) return bundledResult;
+    return null;
+  }
+  /**
+   * Check if API is available.
+   */
+  async checkApiAvailability() {
+    if (this.offline) return false;
+    try {
+      const response = await fetchWithTimeout(`${this.apiUrl.replace("/v1", "")}/health`, 3e3);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get the source used for the last fetch.
+   */
+  getSourceType() {
+    return this.offline ? "bundled" : "api";
+  }
+};
+async function syncRegistry(cacheDir, apiUrl = DEFAULT_API_URL) {
+  const client = new RegistryClient({ cacheDir, apiUrl, offline: false });
+  const synced = [];
+  const failed = [];
+  const apiAvailable = await client.checkApiAvailability();
+  if (!apiAvailable) {
+    return { synced: [], failed: ["API unavailable"], source: "bundled" };
+  }
+  const types = ["archetypes", "blueprints", "themes", "patterns", "shells"];
+  for (const type of types) {
+    try {
+      const fetchMethod = `fetch${type.charAt(0).toUpperCase()}${type.slice(1)}`;
+      const result = await client[fetchMethod]();
+      if (result.source.type === "api") {
+        synced.push(type);
+      }
+    } catch {
+      failed.push(type);
+    }
+  }
+  return {
+    synced,
+    failed,
+    source: synced.length > 0 ? "api" : "bundled"
+  };
+}
+
+export {
+  RegistryClient,
+  syncRegistry
+};

package/dist/heal-2OPN63OT.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import "./chunk-PDX44BCA.js";
+
+// src/commands/heal.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { validateEssence, evaluateGuard } from "@decantr/essence-spec";
+var GREEN = "\x1B[32m";
+var RED = "\x1B[31m";
+var YELLOW = "\x1B[33m";
+var RESET = "\x1B[0m";
+var DIM = "\x1B[2m";
+async function cmdHeal(projectRoot = process.cwd()) {
+  const essencePath = join(projectRoot, "decantr.essence.json");
+  if (!existsSync(essencePath)) {
+    console.error("No decantr.essence.json found. Run `decantr init` first.");
+    process.exitCode = 1;
+    return;
+  }
+  const essence = JSON.parse(readFileSync(essencePath, "utf-8"));
+  console.log("Scanning for issues...\n");
+  const issues = [];
+  const validation = validateEssence(essence);
+  if (!validation.valid) {
+    for (const err of validation.errors) {
+      issues.push({
+        type: "error",
+        rule: "schema",
+        message: err
+      });
+    }
+  }
+  try {
+    const violations = evaluateGuard(essence, { themeRegistry: /* @__PURE__ */ new Map(), patternRegistry: /* @__PURE__ */ new Map() });
+    for (const v of violations) {
+      issues.push({
+        type: v.severity === "error" ? "error" : "warning",
+        rule: v.rule,
+        message: v.message,
+        suggestion: v.suggestion
+      });
+    }
+  } catch {
+  }
+  if (issues.length === 0) {
+    console.log(`${GREEN}No issues found. Project is healthy.${RESET}`);
+    return;
+  }
+  console.log(`Found ${issues.length} issue(s):
+`);
+  for (const issue of issues) {
+    const icon = issue.type === "error" ? `${RED}x${RESET}` : `${YELLOW}!${RESET}`;
+    console.log(`${icon} [${issue.rule}] ${issue.message}`);
+    if (issue.suggestion) {
+      console.log(`  ${DIM}Suggestion: ${issue.suggestion}${RESET}`);
+    }
+  }
+  console.log(`
+${YELLOW}Manual fixes required. Review the issues above.${RESET}`);
+}
+export {
+  cmdHeal
+};