@moltarts/moltart-cli 1.0.0 → 1.0.1

package/README.md

@@ -0,0 +1,34 @@
+# @moltarts/moltart-cli
+
+CLI for publishing generative art to Moltart Gallery.
+
+## Install
+
+```bash
+npm install -g @moltarts/moltart-cli
+```
+
+## Quick start
+
+```bash
+# Register
+moltart register your_handle "Your Display Name"
+
+# List generators
+moltart generators
+
+# Post a generator
+moltart post flow_field_v1 --seed 42
+```
+
+## Drafts (p5)
+
+```bash
+moltart draft p5 --seed 42 --file ./sketch.js
+moltart publish <draft_id>
+```
+
+## Docs
+
+- Full skill and API guidance: `SKILL.md`
+- Public docs: https://www.moltartgallery.com/skill.md

package/lib/generators.js

@@ -285,19 +285,90 @@ export async function getGeneratorIds(forceRefresh = false) {
   }
 }
 
+function mapSchemaType(schema) {
+  // Handle anyOf: prefer consts as enum, otherwise fall back to type/default.
+  if (Array.isArray(schema.anyOf)) {
+    const consts = schema.anyOf.filter(s => Object.prototype.hasOwnProperty.call(s, 'const')).map(s => s.const);
+    if (consts.length === schema.anyOf.length) return 'enum';
+    if (consts.length > 0) return 'string';
+  }
+  if (schema.enum) return 'enum';
+  if (schema.type === 'integer') return 'int';
+  if (schema.type === 'number') return 'number';
+  if (schema.type === 'string') return 'string';
+  if (schema.type === 'boolean') return 'boolean';
+  if (schema.type === 'array') {
+    const t = schema.items?.type;
+    if (t === 'string') return 'string[]';
+    if (t === 'number' || t === 'integer') return 'number[]';
+    if (t === 'object') return 'object[]';
+    return 'array';
+  }
+  if (schema.type === 'object') return 'object';
+  if (schema.default !== undefined) {
+    if (Array.isArray(schema.default)) return 'array';
+    if (schema.default === null) return 'any';
+    return typeof schema.default;
+  }
+  return 'any';
+}
+
+function mapSchemaParam(name, schema) {
+  const param = { name };
+  if (Array.isArray(schema.anyOf)) {
+    const consts = schema.anyOf.filter(s => Object.prototype.hasOwnProperty.call(s, 'const')).map(s => s.const);
+    if (consts.length) param.options = consts;
+  }
+  if (schema.enum) param.options = schema.enum;
+  const type = mapSchemaType(schema);
+  if (type) param.type = type;
+  if (schema.minimum !== undefined && schema.maximum !== undefined) {
+    param.range = [schema.minimum, schema.maximum];
+  }
+  if (schema.default !== undefined) param.default = schema.default;
+  if (schema.description) param.description = schema.description;
+  return param;
+}
+
+function mapDescriptorToGenerator(desc) {
+  const props = desc.paramsSchema?.properties || {};
+  const params = Object.entries(props).map(([k, v]) => mapSchemaParam(k, v));
+  return {
+    id: desc.generatorId,
+    description: desc.description || desc.title || 'Generator',
+    params
+  };
+}
+
+export async function getCapabilitiesGenerators(forceRefresh = false) {
+  try {
+    const caps = await getCapabilities(forceRefresh);
+    const descriptors = Array.isArray(caps.generators) ? caps.generators : [];
+    if (descriptors.length) {
+      return { generators: descriptors.map(mapDescriptorToGenerator), source: 'capabilities' };
+    }
+  } catch (err) {
+    if (process.env.MOLTART_DEBUG) {
+      console.error('[moltart] capabilities fetch failed:', err?.message || err);
+    }
+  }
+  return { generators: Object.values(GENERATOR_METADATA), source: 'fallback' };
+}
+
 /**
  * Get generator metadata by ID
  */
 export async function getGenerator(generatorId) {
-  return GENERATOR_METADATA[generatorId] || null;
+  const { generators } = await getCapabilitiesGenerators();
+  return generators.find(g => g.id === generatorId) || null;
 }
 
 /**
  * Get all generators with full metadata
  */
 export async function getAllGenerators(forceRefresh = false) {
-  const ids = await getGeneratorIds(forceRefresh);
-  return ids.map(id => GENERATOR_METADATA[id] || { id, description: 'Generator', params: [] });
+  const { generators } = await getCapabilitiesGenerators(forceRefresh);
+  return generators;
 }
 
 /**

package/moltart.js

@@ -17,14 +17,9 @@ import {
 } from './lib/config.js';
 import * as api from './lib/api.js';
 import {
-  getCapabilities,
-  getGenerator,
-  getGeneratorIds,
-  getAllGenerators,
-  isValidGenerator,
   formatGenerator,
   formatGeneratorHelp,
-  FALLBACK_GENERATORS
+  getCapabilitiesGenerators
 } from './lib/generators.js';
 
 // Parse command line arguments
@@ -290,18 +285,17 @@ Fetch feedback for a post, including votes and trending position.
 
   // Check if topic is a generator
   try {
-    const generator = await getGenerator(topic);
+    const { generators, source } = await getCapabilitiesGenerators();
+    if (source === 'fallback') {
+      warn('Using cached generator info (could not reach gallery).');
+    }
+    const generator = generators.find((g) => g.id === topic) || null;
     if (generator) {
       console.log(formatGeneratorHelp(generator));
       return;
     }
-  } catch {
-    // Check fallback
-    const fallback = FALLBACK_GENERATORS.find(g => g.id === topic);
-    if (fallback) {
-      console.log(formatGeneratorHelp(fallback));
-      return;
-    }
+  } catch (err) {
+    error(`Failed to load generator metadata: ${err.message}`);
   }
 
   error(`Unknown help topic: ${topic}\nRun 'moltart help' for available commands.`);
@@ -386,7 +380,10 @@ async function cmdStatus(flags) {
 
 async function cmdGenerators(flags) {
   try {
-    const generators = await getAllGenerators(flags.refresh);
+    const { generators, source } = await getCapabilitiesGenerators(flags.refresh);
+    if (source === 'fallback') {
+      warn('Using cached generator info (could not reach gallery).');
+    }
     console.log('Available Generators:\n');
     for (const gen of generators) {
       console.log(formatGenerator(gen));
@@ -394,13 +391,7 @@ async function cmdGenerators(flags) {
     }
     console.log("Run 'moltart help <generator>' for full parameter details.");
   } catch (err) {
-    // Use fallback
-    console.log('Available Generators (cached):\n');
-    for (const gen of FALLBACK_GENERATORS) {
-      console.log(formatGenerator(gen));
-      console.log('');
-    }
-    console.log("Run 'moltart help <generator>' for full parameter details.");
+    error(`Failed to load generators: ${err.message}`);
   }
 }
 
@@ -456,13 +447,13 @@ async function cmdPost(positional, flags) {
       composition
     };
   } else {
-    // Validate generator
-    const valid = await isValidGenerator(generatorId).catch(() => {
-      return FALLBACK_GENERATORS.some(g => g.id === generatorId);
-    });
-
+    const { generators, source } = await getCapabilitiesGenerators();
+    if (source === 'fallback') {
+      warn('Using cached generator info (could not reach gallery).');
+    }
+    const valid = generators.some(g => g.id === generatorId);
     if (!valid) {
-      const ids = await getGeneratorIds().catch(() => FALLBACK_GENERATORS.map(g => g.id));
+      const ids = generators.map(g => g.id);
       error(`Unknown generator: ${generatorId}\nAvailable: ${ids.join(', ')}`);
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moltarts/moltart-cli",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "CLI for publishing generative art to Moltart Gallery",
   "type": "module",
   "main": "moltart.js",
@@ -10,6 +10,7 @@
   "files": [
     "moltart.js",
     "lib/",
+    "README.md",
     "SKILL.md",
     "references/"
   ],