@decantr/cli 1.0.0 → 1.1.0

package/dist/chunk-K6MIDPQH.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+// src/registry.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from "fs";
+import { join } from "path";
+import { RegistryAPIClient } from "@decantr/registry";
+var DEFAULT_API_URL = "https://api.decantr.ai/v1";
+var ALL_CONTENT_TYPES = ["themes", "patterns", "recipes", "blueprints", "archetypes", "shells"];
+function loadFromCache(cacheDir, contentType, id, namespace) {
+  const nsDir = namespace ? join(cacheDir, namespace) : cacheDir;
+  const cachePath = id ? join(nsDir, contentType, `${id}.json`) : join(nsDir, 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, namespace = "@official") {
+  const dir = join(cacheDir, namespace, 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;
+  apiClient;
+  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;
+    this.apiClient = new RegistryAPIClient({
+      baseUrl: this.apiUrl,
+      apiKey: options.apiKey
+    });
+  }
+  /**
+   * Load content from .decantr/custom/{contentType}/{id}.json
+   * Works for ALL content types, not just themes.
+   */
+  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;
+    }
+  }
+  /**
+   * List all custom content of a given type from .decantr/custom/{type}/
+   */
+  listCustomContent(contentType) {
+    const dir = join(this.projectRoot, ".decantr", "custom", contentType);
+    if (!existsSync(dir)) return [];
+    try {
+      return readdirSync(dir).filter((f) => f.endsWith(".json")).map((f) => {
+        const data = JSON.parse(readFileSync(join(dir, f), "utf-8"));
+        return { id: data.id || f.replace(".json", ""), ...data };
+      });
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Unified fetch for a content list.
+   * Resolution: API -> Cache. Custom items are merged into the list.
+   */
+  async fetchContentList(contentType, namespace) {
+    let apiItems = [];
+    let source = { type: "cache" };
+    if (!this.offline) {
+      try {
+        const apiResult = await this.apiClient.listContent(contentType, { namespace });
+        apiItems = apiResult.items;
+        source = { type: "api", url: this.apiUrl };
+        saveToCache(this.cacheDir, contentType, null, apiResult, namespace || "@official");
+      } catch {
+      }
+    }
+    if (apiItems.length === 0) {
+      const cacheResult = loadFromCache(
+        this.cacheDir,
+        contentType,
+        void 0,
+        namespace
+      );
+      if (cacheResult) {
+        apiItems = cacheResult.data.items;
+        source = { type: "cache" };
+      }
+    }
+    const customItems = this.listCustomContent(contentType);
+    const allItems = [...customItems, ...apiItems];
+    return {
+      data: { items: allItems, total: allItems.length },
+      source
+    };
+  }
+  /**
+   * Unified fetch for a single content item.
+   * Resolution: Custom -> API -> Cache
+   */
+  async fetchContentItem(contentType, id, namespace = "@official") {
+    const customId = id.startsWith("custom:") ? id.slice(7) : id;
+    const customResult = this.loadCustomContent(contentType, customId);
+    if (customResult) return customResult;
+    if (id.startsWith("custom:")) return null;
+    if (!this.offline) {
+      try {
+        const data = await this.apiClient.getContent(contentType, namespace, id);
+        saveToCache(this.cacheDir, contentType, id, data, namespace);
+        return { data, source: { type: "api", url: this.apiUrl } };
+      } catch {
+      }
+    }
+    return loadFromCache(this.cacheDir, contentType, id, namespace);
+  }
+  // ── Convenience methods (delegate to unified fetch) ──
+  async fetchArchetypes() {
+    return this.fetchContentList("archetypes");
+  }
+  async fetchArchetype(id) {
+    return this.fetchContentItem("archetypes", id);
+  }
+  async fetchBlueprints() {
+    return this.fetchContentList("blueprints");
+  }
+  async fetchBlueprint(id) {
+    return this.fetchContentItem("blueprints", id);
+  }
+  async fetchThemes() {
+    return this.fetchContentList("themes");
+  }
+  async fetchTheme(id) {
+    return this.fetchContentItem("themes", id);
+  }
+  async fetchPatterns() {
+    return this.fetchContentList("patterns");
+  }
+  async fetchPattern(id) {
+    return this.fetchContentItem("patterns", id);
+  }
+  async fetchShells() {
+    return this.fetchContentList("shells");
+  }
+  async fetchShell(id) {
+    return this.fetchContentItem("shells", id);
+  }
+  async fetchRecipes() {
+    return this.fetchContentList("recipes");
+  }
+  async fetchRecipe(id) {
+    return this.fetchContentItem("recipes", id);
+  }
+  /**
+   * Check if API is available.
+   */
+  async checkApiAvailability() {
+    if (this.offline) return false;
+    return this.apiClient.checkHealth();
+  }
+};
+async function syncRegistry(cacheDir, apiUrl = DEFAULT_API_URL) {
+  const apiClient = new RegistryAPIClient({ baseUrl: apiUrl });
+  const synced = [];
+  const failed = [];
+  const healthy = await apiClient.checkHealth();
+  if (!healthy) {
+    return { synced: [], failed: ["API unavailable"] };
+  }
+  for (const type of ALL_CONTENT_TYPES) {
+    try {
+      const result = await apiClient.listContent(type, { namespace: "@official" });
+      saveToCache(cacheDir, type, null, result, "@official");
+      for (const item of result.items) {
+        const id = item.id || item.slug;
+        if (id) {
+          saveToCache(cacheDir, type, id, item, "@official");
+        }
+      }
+      synced.push(type);
+    } catch {
+      failed.push(type);
+    }
+  }
+  return { synced, failed };
+}
+
+export {
+  RegistryClient,
+  syncRegistry
+};