spyne-cli 0.6.8 → 0.7.1

package/src/core/generate-module.js

@@ -0,0 +1,146 @@
+// Core module generation. No terminal output — returns structured results.
+// The CLI layer is responsible for rendering these.
+
+import path from 'path';
+import GenerateFileString from '../templates/generate-file-string.js';
+import {detectSpyneProject} from './create-app.js';
+import {getLocalFileDirectory, onSaveSpyneFileToDir} from '../utils/file-utils.js';
+import {insertChannelStrings} from '../utils/insert-channel-strings-to-index-file.js';
+import {Data} from '../spyne-template-prompts.js';
+
+const {fileTypesArr} = Data;
+
+const toPascalCase = (str) => String(str).
+    replace(/\.js$/, '').
+    split(/[-_\s]+/).
+    filter(Boolean).
+    map((s) => s.charAt(0).toUpperCase() + s.slice(1)).
+    join('');
+
+const toConstantCase = (str) => {
+  const name = String(str).toLowerCase().startsWith('channel')
+      ? str
+      : `Channel${str}`;
+  return name.replace(/([a-z0-9])([A-Z])/g, '$1_$2').
+      replace(/[-\s]+/g, '_').
+      toUpperCase();
+};
+
+const toMethodPrefix = (className) => {
+  const words = String(className).
+      replace(/([a-z0-9])([A-Z])/g, '$1 $2').
+      split(/[\s-_]+/).
+      filter(Boolean).
+      slice(0, 2);
+  const joined = words.map(
+      (w, i) => i === 0
+          ? w.toLowerCase()
+          : w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join('');
+  return `${joined}$`;
+};
+
+const withTrailingSlash = (dir) => dir.endsWith('/') ? dir : `${dir}/`;
+
+/**
+ * Fill in the same defaults the interactive prompts would have offered, so a
+ * flags-only invocation produces identical output to the picker.
+ */
+export const resolveModuleArgs = (args = {}) => {
+  const {fileType} = args;
+  const fileName = String(args.fileName).endsWith('.js')
+      ? args.fileName
+      : `${args.fileName}.js`;
+  const className = args.className || toPascalCase(fileName);
+  const fileDirectory = withTrailingSlash(
+      args.fileDirectory || getLocalFileDirectory(fileType));
+
+  const resolved = {fileType, fileName, className, fileDirectory};
+
+  if (fileType === 'Channel') {
+    resolved.channelName = args.channelName || toConstantCase(className);
+    resolved.replayLastPayload = args.replayLastPayload === true ||
+        args.replayLastPayload === 'true';
+  }
+
+  if (fileType === 'SpyneTrait') {
+    resolved.methodPrefix = args.methodPrefix || toMethodPrefix(className);
+  }
+
+  return resolved;
+};
+
+/**
+ * Generate a single Spyne module file.
+ *
+ * @param {Object} args
+ * @returns {Promise<Object>} structured result — never throws for expected
+ *   failures (missing name, existing file); those surface on the result.
+ */
+export async function generateModule(args = {}) {
+  if (!fileTypesArr.includes(args.fileType)) {
+    return {
+      ok: false,
+      error: {
+        code: 'INVALID_FILE_TYPE',
+        message: `Unknown file type "${args.fileType}". Expected one of: ${fileTypesArr.join(
+            ', ')}.`,
+      },
+    };
+  }
+
+  if (!args.fileName) {
+    return {
+      ok: false,
+      error: {code: 'MISSING_FILE_NAME', message: 'A file name is required.'},
+    };
+  }
+
+  // Modules generate into an existing project; an app does not exist yet.
+  if (args.requireProject !== false && !detectSpyneProject().isSpyneProject) {
+    return {
+      ok: false,
+      error: {
+        code: 'NOT_IN_SPYNE_PROJECT',
+        message: 'Run this inside a SpyneJS project. To start a new one: spyne-cli create-app <app-name>',
+      },
+    };
+  }
+
+  const resolved = resolveModuleArgs(args);
+  const {fileType, fileName, className, fileDirectory} = resolved;
+  const {fileString} = new GenerateFileString(fileType, resolved);
+  const saved = onSaveSpyneFileToDir(fileString, fileName, fileDirectory);
+
+  // The CLI prints the generated source for copy-paste when a write fails, so
+  // failure results carry the same payload a success would.
+  if (!saved.fileHasSaved) {
+    return {
+      ok: false,
+      error: {
+        code: saved.fileExists ? 'FILE_ALREADY_EXISTS' : 'WRITE_FAILED',
+        message: saved.fileExists
+            ? `${saved.fileDirPath} already exists.`
+            : `Could not write ${saved.fileDirPath}.`,
+      },
+      ...resolved,
+      filePath: saved.fileDirPath,
+      errorType: saved.errorType,
+      channelRegistered: false,
+      fileString,
+    };
+  }
+
+  let channelRegistered = false;
+  if (fileType === 'Channel') {
+    channelRegistered = insertChannelStrings(className, fileName).fileHasSaved;
+  }
+
+  return {
+    ok: true,
+    ...resolved,
+    filePath: saved.fileDirPath,
+    relativePath: path.relative(process.cwd(), saved.fileDirPath),
+    channelRegistered,
+    fileString,
+  };
+}

package/src/registry.js

@@ -0,0 +1,180 @@
+// Single source of truth for every spyne-cli command.
+//
+// Three consumers read this registry: the interactive picker, the argv parser,
+// and (in a later release) the SpyneJS MCP server. Adding a command here makes
+// it available to all three — no other file needs to change.
+
+import {createApp, DEFAULT_TEMPLATE, TEMPLATES} from './core/create-app.js';
+import {generateModule} from './core/generate-module.js';
+
+const templateValues = Object.keys(TEMPLATES);
+
+const moduleArgs = (extra = {}) => ({
+  fileName: {
+    type: 'string',
+    positional: 0,
+    required: true,
+    description: 'File name for the generated module (.js is appended if omitted).',
+  },
+  className: {
+    type: 'string',
+    description: 'Class name. Defaults to the PascalCase form of the file name.',
+  },
+  fileDirectory: {
+    type: 'string',
+    alias: 'd',
+    description: 'Directory to write into. Defaults to the conventional path for this type.',
+  },
+  ...extra,
+});
+
+/**
+ * A generation target: interactive via the picker, deterministic via flags,
+ * enumerable programmatically.
+ *
+ * @typedef {Object} Command
+ * @property {string} name            command name as typed
+ * @property {string} summary         one line, shown in help and the picker
+ * @property {'app'|'module'} kind    app creates a directory; module writes into a project
+ * @property {Object} args            arg name -> schema
+ * @property {Function} handler       async (args) => structured result
+ */
+export const commands = [
+  {
+    name: 'create-app',
+    summary: 'Create a new SpyneJS application',
+    pickerLabel: 'App',
+    kind: 'app',
+    args: {
+      appName: {
+        type: 'string',
+        positional: 0,
+        required: true,
+        description: 'Directory name for the new application.',
+      },
+      template: {
+        type: 'string',
+        alias: 't',
+        enum: templateValues,
+        default: DEFAULT_TEMPLATE,
+        description: 'Template to scaffold from.',
+      },
+      prompt: {
+        type: 'string',
+        alias: 'p',
+        description: 'Site description — AI generates pages, routes, content, ' +
+            'and images (shell template only).',
+      },
+      install: {
+        type: 'boolean',
+        default: true,
+        negatable: true,
+        description: 'Install dependencies after scaffolding.',
+        negatedDescription: 'Skip dependency installation.',
+      },
+      git: {
+        type: 'boolean',
+        default: true,
+        negatable: true,
+        description: 'Initialise a fresh git repository.',
+        negatedDescription: 'Skip git initialisation.',
+      },
+    },
+    handler: createApp,
+  },
+  {
+    name: 'create-viewstream',
+    summary: 'Generate a ViewStream class',
+    pickerLabel: 'ViewStream',
+    kind: 'module',
+    fileType: 'ViewStream',
+    args: moduleArgs(),
+    handler: (args) => generateModule({...args, fileType: 'ViewStream'}),
+  },
+  {
+    name: 'create-domelement',
+    summary: 'Generate a DomElement class',
+    pickerLabel: 'DomElement',
+    kind: 'module',
+    fileType: 'DomElement',
+    args: moduleArgs(),
+    handler: (args) => generateModule({...args, fileType: 'DomElement'}),
+  },
+  {
+    name: 'create-channel',
+    summary: 'Generate a Channel class and register it',
+    pickerLabel: 'Channel',
+    kind: 'module',
+    fileType: 'Channel',
+    args: moduleArgs({
+      channelName: {
+        type: 'string',
+        description: 'Channel name. Defaults to the CONSTANT_CASE form of the class name.',
+      },
+      replayLastPayload: {
+        type: 'boolean',
+        default: false,
+        description: 'Send the cached payload to new subscribers.',
+      },
+    }),
+    handler: (args) => generateModule({...args, fileType: 'Channel'}),
+  },
+  {
+    name: 'create-trait',
+    summary: 'Generate a SpyneTrait class',
+    pickerLabel: 'SpyneTrait',
+    kind: 'module',
+    fileType: 'SpyneTrait',
+    args: moduleArgs({
+      methodPrefix: {
+        type: 'string',
+        description: 'String prepended to all trait methods. Derived from the class name by default.',
+      },
+    }),
+    handler: (args) => generateModule({...args, fileType: 'SpyneTrait'}),
+  },
+];
+
+// `new` shipped in 0.6.x and stays working; create-app is canonical.
+export const aliases = {
+  new: {command: 'create-app', deprecated: true, since: '0.7.1'},
+};
+
+/**
+ * Flags that existed in 0.6.x and no longer do. Declared rather than deleted so
+ * the CLI can say what happened instead of reporting an unknown option.
+ */
+export const removedFlags = {
+  spa: {
+    removedIn: '0.7.1',
+    message: '"--spa" has been removed. Pick a template with --template starter|shell.',
+  },
+};
+
+export const commandNames = commands.map((c) => c.name);
+
+export const getCommand = (name) => {
+  if (!name) return undefined;
+  const alias = aliases[name];
+  const target = alias ? alias.command : name;
+  return commands.find((c) => c.name === target);
+};
+
+export const getAlias = (name) => aliases[name];
+
+export const moduleCommands = commands.filter((c) => c.kind === 'module');
+
+export const appCommands = commands.filter((c) => c.kind === 'app');
+
+/**
+ * Registry as plain data — no handlers, no functions. This is the shape the
+ * MCP server will enumerate to expose each generation target as a capability.
+ */
+export const describeCommands = () => commands.map(
+    ({name, summary, kind, args}) => ({
+      name,
+      summary,
+      kind,
+      args: Object.fromEntries(
+          Object.entries(args).map(([argName, schema]) => [argName, {...schema}])),
+    }));

package/src/spyne-file-prompt.js

@@ -1,14 +1,25 @@
 import enquirer from 'enquirer';
 const {prompt, Select} = enquirer;
+import c from 'ansi-colors';
 
 import {Data} from './spyne-template-prompts.js';
 const {promptInputHash} = Data;
 import GeneratePromptInputObject from './templates/generate-prompt-input-object.js';
-import GenerateFileString from './templates/generate-file-string.js';
-import {onSaveSpyneFileToDir} from './utils/file-utils.js';
-import {generatePromptOutput} from './templates/generate-prompt-output.js';
-import {addChannelToIndexJS} from './utils/add-channel-to-index-file.js';
-import {insertChannelStrings} from './utils/insert-channel-strings-to-index-file.js';
+import {appCommands, moduleCommands} from './registry.js';
+import {generateModule} from './core/generate-module.js';
+import {createApp, detectSpyneProject} from './core/create-app.js';
+import {
+  appNamePrompt,
+  createProgressReporter,
+  renderAppResult,
+  renderError,
+  renderModuleResult,
+  selectSizing,
+  templatePrompt,
+} from './cli/render.js';
+
+// Picker labels come from the registry, so command messaging has one home.
+const APP_LABELS = new Set(appCommands.map((cmd) => cmd.pickerLabel));
 
 export default class SpyneFilePrompt {
 
@@ -32,48 +43,84 @@ export default class SpyneFilePrompt {
     return props.map(mapInputTypesToPrompObj);
   }
 
+  /**
+   * The picker is a renderer over the registry: App first, then every module
+   * command in registry order.
+   */
   getSelectPromptObj() {
     const promptGen = new GeneratePromptInputObject('selectFileType');
-    return promptGen.getPrompObject();
+    const promptObj = promptGen.getPrompObject();
 
+    promptObj.choices = [
+      ...appCommands.map((cmd) => ({
+        name: cmd.pickerLabel,
+        message: c.greenBright(cmd.pickerLabel),
+        hint: c.dim(`— ${cmd.summary}`),
+      })),
+      ...moduleCommands.map((cmd) => c.greenBright(cmd.pickerLabel)),
+    ];
+
+    Object.assign(promptObj, selectSizing(promptObj.choices.length));
+
+    return promptObj;
   }
 
-  saveFileAndSendOutput(answers) {
-    const {fileType, fileName, fileDirectory, className} = answers;
-    const {fileString} = new GenerateFileString(fileType, answers);
-    const savedProps = onSaveSpyneFileToDir(fileString, fileName, fileDirectory);
+  async saveFileAndSendOutput(answers) {
+    const result = await generateModule(answers);
 
-    // default is no channel to be registered, yet
-    let channelHasRegistered = false;
+    if (!result.ok && result.error.code === 'NOT_IN_SPYNE_PROJECT') {
+      console.log(renderError(result.error));
+      process.exitCode = 1;
+      return result;
+    }
 
-    if (fileType === 'Channel'){
-      //const savedChannelToIndexProps = addChannelToIndexJS(className, fileName);
-      const savedChannelToIndexProps = insertChannelStrings(className, fileName);
+    console.log(renderModuleResult(result));
+    if (!result.ok) process.exitCode = 1;
+    return result;
+  }
 
-      // check if channel has been registered
-      channelHasRegistered = savedChannelToIndexProps.fileHasSaved;
+  async runAppPrompt() {
+    const {isSpyneProject, root} = detectSpyneProject();
+
+    if (isSpyneProject) {
+      const {proceed} = await prompt({
+        type: 'confirm',
+        name: 'proceed',
+        initial: false,
+        message: c.yellow(
+            `This creates a new app inside an existing SpyneJS project (${root}) — continue?`),
+      });
+      if (!proceed) return undefined;
     }
 
-    const msgOutput = generatePromptOutput(answers, savedProps, fileString, channelHasRegistered);
+    // Template first: the general choice before the specific one.
+    const answers = await prompt([templatePrompt(), appNamePrompt()]);
 
+    const result = await createApp({
+      ...answers,
+      onProgress: createProgressReporter(),
+    });
 
-    console.log(msgOutput);
+    console.log(result.ok
+        ? renderAppResult(result)
+        : renderError(result.error));
+
+    if (!result.ok) process.exitCode = 1;
+    return result;
   }
 
   async startPrompt() {
-    const selectPromptObj = this.getSelectPromptObj();
-    //console.log('select prompt obj is ',selectPromptObj);
-    const selectPrompt = new Select(selectPromptObj);
-    const onSelectComplete = async (fileType) => {
-      const filePromptArr = SpyneFilePrompt.getFilePrompt(fileType);
-      //console.log("promp arr is ",filePromptArr);
-      const filePrompt = await prompt(filePromptArr);
-      const answersObj = Object.assign({}, filePrompt, {fileType});
-      this.saveFileAndSendOutput(answersObj);
-    };
+    const selectPrompt = new Select(this.getSelectPromptObj());
+    const selection = await selectPrompt.run();
 
-    selectPrompt.run().then(onSelectComplete);
+    if (APP_LABELS.has(selection)) {
+      return this.runAppPrompt();
+    }
 
+    const filePromptArr = SpyneFilePrompt.getFilePrompt(selection);
+    const filePrompt = await prompt(filePromptArr);
+    return this.saveFileAndSendOutput(
+        Object.assign({}, filePrompt, {fileType: selection}));
   }
 
 };

package/src/templates/generate-prompt-input-fields.js

@@ -174,7 +174,7 @@ const generateMesage = () => {
   const defaultMsgFn = messageColor(`Enter the ${_fileType} file name`);
 
   const inputTypeHash = {
-    selectFileType: messageColor(`Select file type`),
+    selectFileType: messageColor(`What would you like to create?`),
     fileName: defaultMsgFn,
     className: messageColor(`Enter the ${_fileType} class name`),
     fileDirectory: messageColor(`Enter where you would like to save the ${_fileType} file`),

package/src/ui.js

@@ -1,11 +1,15 @@
 import figlet from 'figlet';
 import chalk from 'chalk';
+import { readFileSync } from 'fs';
+
+const { version } = JSON.parse(
+    readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
 
 export class SpyneCliUI {
 
   constructor() {}
   static title(){
-    const figletTxt = figlet.textSync('spyne-cli 6.8', {
+    const figletTxt = figlet.textSync(`spyne-cli ${version}`, {
       horizontalLayout: 'universal smushing'
     })
     const chalkOutput = chalk.blue(figletTxt);

package/lib/ansi.js

@@ -1,116 +0,0 @@
-'use strict';
-
-const isTerm = process.env.TERM_PROGRAM === 'Apple_Terminal';
-const colors = require('ansi-colors');
-const utils = require('./utils');
-const ansi = module.exports = exports;
-const ESC = '\u001b[';
-const BEL = '\u0007';
-let hidden = false;
-
-const code = ansi.code = {
-  bell: BEL,
-  beep: BEL,
-  beginning: `${ESC}G`,
-  down: `${ESC}J`,
-  esc: ESC,
-  getPosition: `${ESC}6n`,
-  hide: `${ESC}?25l`,
-  line: `${ESC}2K`,
-  lineEnd: `${ESC}K`,
-  lineStart: `${ESC}1K`,
-  restorePosition: ESC + (isTerm ? '8' : 'u'),
-  savePosition: ESC + (isTerm ? '7' : 's'),
-  screen: `${ESC}2J`,
-  show: `${ESC}?25h`,
-  up: `${ESC}1J`
-};
-
-const cursor = ansi.cursor = {
-  get hidden() {
-    return hidden;
-  },
-
-  hide() {
-    hidden = true;
-    return code.hide;
-  },
-  show() {
-    hidden = false;
-    return code.show;
-  },
-
-  forward: (count = 1) => `${ESC}${count}C`,
-  backward: (count = 1) => `${ESC}${count}D`,
-  nextLine: (count = 1) => `${ESC}E`.repeat(count),
-  prevLine: (count = 1) => `${ESC}F`.repeat(count),
-
-  up: (count = 1) => count ? `${ESC}${count}A` : '',
-  down: (count = 1) => count ? `${ESC}${count}B` : '',
-  right: (count = 1) => count ? `${ESC}${count}C` : '',
-  left: (count = 1) => count ? `${ESC}${count}D` : '',
-
-  to(x, y) {
-    return y ? `${ESC}${y + 1};${x + 1}H` : `${ESC}${x + 1}G`;
-  },
-
-  move(x = 0, y = 0) {
-    let res = '';
-    res += (x < 0) ? cursor.left(-x) : (x > 0) ? cursor.right(x) : '';
-    res += (y < 0) ? cursor.up(-y) : (y > 0) ? cursor.down(y) : '';
-    return res;
-  },
-
-  restore(state = {}) {
-    let { after, cursor, initial, input, prompt, size, value } = state;
-    initial = utils.isPrimitive(initial) ? String(initial) : '';
-    input = utils.isPrimitive(input) ? String(input) : '';
-    value = utils.isPrimitive(value) ? String(value) : '';
-
-    if (size) {
-      let codes = ansi.cursor.up(size) + ansi.cursor.to(prompt.length);
-      let diff = input.length - cursor;
-      if (diff > 0) {
-        codes += ansi.cursor.left(diff);
-      }
-      return codes;
-    }
-
-    if (value || after) {
-      let pos = (!input && !!initial) ? -initial.length : -input.length + cursor;
-      if (after) pos -= after.length;
-      if (input === '' && initial && !prompt.includes(initial)) {
-        pos += initial.length;
-      }
-      return ansi.cursor.move(pos);
-    }
-  }
-};
-
-const erase = ansi.erase = {
-  screen: code.screen,
-  up: code.up,
-  down: code.down,
-  line: code.line,
-  lineEnd: code.lineEnd,
-  lineStart: code.lineStart,
-  lines(n) {
-    let str = '';
-    for (let i = 0; i < n; i++) {
-      str += ansi.erase.line + (i < n - 1 ? ansi.cursor.up(1) : '');
-    }
-    if (n) str += ansi.code.beginning;
-    return str;
-  }
-};
-
-ansi.clear = (input = '', columns = process.stdout.columns) => {
-  if (!columns) return erase.line + cursor.to(0);
-  let width = str => [...colors.unstyle(str)].length;
-  let lines = input.split(/\r?\n/);
-  let rows = 0;
-  for (let line of lines) {
-    rows += 1 + Math.floor(Math.max(width(line) - 1, 0) / columns);
-  }
-  return (erase.line + cursor.prevLine()).repeat(rows - 1) + erase.line + cursor.to(0);
-};

package/lib/combos.js

@@ -1,75 +0,0 @@
-'use strict';
-
-/**
- * Actions are mappings from keypress event names to method names
- * in the prompts.
- */
-
-exports.ctrl = {
-  a: 'first',
-  b: 'backward',
-  c: 'cancel',
-  d: 'deleteForward',
-  e: 'last',
-  f: 'forward',
-  g: 'reset',
-  i: 'tab',
-  k: 'cutForward',
-  l: 'reset',
-  n: 'newItem',
-  m: 'cancel',
-  j: 'submit',
-  p: 'search',
-  r: 'remove',
-  s: 'save',
-  u: 'undo',
-  w: 'cutLeft',
-  x: 'toggleCursor',
-  v: 'paste'
-};
-
-exports.shift = {
-  up: 'shiftUp',
-  down: 'shiftDown',
-  left: 'shiftLeft',
-  right: 'shiftRight',
-  tab: 'prev'
-};
-
-exports.fn = {
-  up: 'pageUp',
-  down: 'pageDown',
-  left: 'pageLeft',
-  right: 'pageRight',
-  delete: 'deleteForward'
-};
-
-// <alt> on Windows
-exports.option = {
-  b: 'backward',
-  f: 'forward',
-  d: 'cutRight',
-  left: 'cutLeft',
-  up: 'altUp',
-  down: 'altDown'
-};
-
-exports.keys = {
-  pageup: 'pageUp', // <fn>+<up> (mac), <Page Up> (windows)
-  pagedown: 'pageDown', // <fn>+<down> (mac), <Page Down> (windows)
-  home: 'home', // <fn>+<left> (mac), <home> (windows)
-  end: 'end', // <fn>+<right> (mac), <end> (windows)
-  cancel: 'cancel',
-  delete: 'deleteForward',
-  backspace: 'delete',
-  down: 'down',
-  enter: 'submit',
-  escape: 'cancel',
-  left: 'left',
-  space: 'space',
-  number: 'number',
-  return: 'submit',
-  right: 'right',
-  tab: 'next',
-  up: 'up'
-};