spyne-cli 0.6.0 → 0.6.5

package/README.md

@@ -16,10 +16,9 @@ To install the `spyne-cli`, you need to have Node.js and npm installed on your s
 1. Install the package globally:
 
    ```bash
-   npm install -g @spynejs/spyne-cli
+   npm install -g spyne-cli
    ```
 
-
 ## Usage
 
 ### Creating a New SpyneJS Application
@@ -100,6 +99,3 @@ Contributions are welcome! Please feel free to submit a Pull Request or open an
 ## License
 
 This project is licensed under the MIT License.
-```
-
-You can now paste this content directly into your `README.md` file. Let me know if you need further assistance!

package/index.js

@@ -8,6 +8,9 @@ import SpyneFilePrompt from './src/spyne-file-prompt.js';
 const command = process.argv[2];
 const appName = process.argv[3];
 
+// Simple check if user included "-spa" or "--spa" anywhere in the process.argv
+const isSPA = process.argv.includes('-spa') || process.argv.includes('--spa');
+
 const startPromptFn = async () => {
   clear();
   SpyneCliUI.title();
@@ -16,11 +19,10 @@ const startPromptFn = async () => {
 };
 
 if (command === 'new' && appName) {
-  // We can use an immediately-invoked async function
-  // OR top-level await if your Node version supports it.
   (async () => {
     try {
-      await createNewApp(appName);
+      // Pass the isSPA boolean to createNewApp
+      await createNewApp(appName, isSPA);
     } catch (err) {
       console.error('Failed to create new application:', err.message);
       process.exit(1);

package/package.json

@@ -4,7 +4,7 @@
     "spyne-cli": "index.js"
   },
   "type": "module",
-  "version": "0.6.0",
+  "version": "0.6.5",
   "description": "Generates spyne objects and saves them to standard spyne.",
   "main": "index.js",
   "scripts": {
@@ -35,7 +35,6 @@
     "ora": "^8.1.1",
     "package-up": "^5.0.0",
     "pkg-dir": "^8.0.0",
-    "pkg-up": "^5.0.0",
     "ramda": "^0.30.1",
     "read-pkg": "^9.0.1",
     "recast": "^0.23.9",

package/src/spyne-file-prompt.js

@@ -8,6 +8,7 @@ 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';
 
 export default class SpyneFilePrompt {
 
@@ -46,7 +47,8 @@ export default class SpyneFilePrompt {
     let channelHasRegistered = false;
 
     if (fileType === 'Channel'){
-      const savedChannelToIndexProps = addChannelToIndexJS(className, fileName);
+      //const savedChannelToIndexProps = addChannelToIndexJS(className, fileName);
+      const savedChannelToIndexProps = insertChannelStrings(className, fileName);
 
       // check if channel has been registered
       channelHasRegistered = savedChannelToIndexProps.fileHasSaved;

package/src/spyne-starter-app-create.js

@@ -12,10 +12,8 @@ async function installDependencies(appName) {
   }).start();
 
   return new Promise((resolve, reject) => {
-    // Use --silent to suppress npm logs
     const child = spawn('npm', ['install', '--silent'], {
       cwd: appName,
-      // stdio: 'ignore' → all output is ignored, the spinner continues unblocked
       stdio: 'ignore',
     });
 
@@ -31,28 +29,93 @@ async function installDependencies(appName) {
   });
 }
 
-export async function createNewApp(appName) {
+/**
+ * Update <title> in index.tmpl.html
+ * @param {string} targetDir
+ * @param {string} appName
+ */
+function updateIndexTitle(targetDir, appName) {
+  const indexFilePath = path.join(targetDir, 'src', 'index.tmpl.html');
+  if (!fs.existsSync(indexFilePath)) return; // skip if not found
+
+  let content = fs.readFileSync(indexFilePath, 'utf-8');
+  // Replace first occurrence of <title>...</title>
+  content = content.replace(/<title>.*<\/title>/, `<title>${appName}</title>`);
+
+  fs.writeFileSync(indexFilePath, content, 'utf-8');
+}
+
+/**
+ * Update "name" field in package.json
+ * @param {string} targetDir
+ * @param {string} appName
+ */
+function updatePackageName(targetDir, appName) {
+  const pkgPath = path.join(targetDir, 'package.json');
+  if (!fs.existsSync(pkgPath)) return; // skip if not found
+
+  const pkgData = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+
+  // sanitize: e.g. convert to lowercase, replace spaces with dashes
+  const sanitizedName = appName
+  .toLowerCase()
+  .replace(/\s+/g, '-')
+  .replace(/[^a-z0-9-_]/g, ''); // remove any non-alphanumeric (optional)
+
+  pkgData.name = sanitizedName || 'my-spyne-app';
+
+  fs.writeFileSync(pkgPath, JSON.stringify(pkgData, null, 2), 'utf-8');
+}
+
+/**
+ * Update the project details (title, pkg name)
+ */
+function updateProjectDetails(targetDir, appName) {
+  updateIndexTitle(targetDir, appName);
+  updatePackageName(targetDir, appName);
+}
+
+/**
+ * Creates a new Spyne app in the directory `appName`.
+ * If isSPA is true, clones the single-page-app template (spa-base-alpha).
+ * Otherwise, clones the default starter-app-alpha.
+ *
+ * @param {string} appName - Name of the app / folder
+ * @param {boolean} isSPA  - Whether to clone the SPA repo
+ */
+export async function createNewApp(appName, isSPA = false) {
   const targetDir = path.resolve(process.cwd(), appName);
-  const repoUrl = 'https://github.com/nybatista/starter-app-alpha.git';
+
+  // Choose repo based on isSPA flag
+  const repoUrl = isSPA
+      ? 'https://github.com/nybatista/spa-base-alpha.git'
+      : 'https://github.com/nybatista/starter-app-alpha.git';
+
   const git = simpleGit();
 
   console.log(c.cyan(`\nCreating a new Spyne app in ${c.bold(appName)}...`));
+  console.log(c.yellow(`Using repo: ${repoUrl}`));
 
   // 1) Clone repository with Ora spinner
   let spinner = ora({
-    text: c.cyan('Cloning starter-app repository...'),
+    text: c.cyan('Cloning repository...'),
     spinner: 'dots',
   }).start();
 
   try {
-    await git.clone(repoUrl, targetDir, ['--depth=1']);
-    spinner.succeed(c.greenBright('Starter App cloned successfully!'));
+    await git.clone(repoUrl, targetDir, [
+      '--branch=main',
+      '--single-branch',
+      '--depth=1'
+    ]);
+
+    spinner.succeed(c.greenBright('Repository cloned successfully!'));
   } catch (err) {
     spinner.fail(c.red(`Failed to clone the repository: ${err.message}`));
     process.exit(1);
   }
 
-  // 2) Remove .git (silent - no user message)
+  // 2) Remove .git
   try {
     fs.rmSync(path.join(targetDir, '.git'), { recursive: true, force: true });
   } catch (err) {
@@ -60,7 +123,15 @@ export async function createNewApp(appName) {
     process.exit(1);
   }
 
-  // 3) Asynchronous install (silent)
+  // 3) Update index.tmpl.html <title> and package.json name
+  try {
+    updateProjectDetails(targetDir, appName);
+  } catch (err) {
+    console.error(c.red(`Failed to update project details: ${err.message}`));
+    // not a fatal error in most cases, but you can decide to exit if needed
+  }
+
+  // 4) Install dependencies
   try {
     await installDependencies(appName);
   } catch (err) {
@@ -68,7 +139,7 @@ export async function createNewApp(appName) {
     process.exit(1);
   }
 
-  // 4) Final success message
+  // 5) Final message
   console.log(`\n${c.greenBright('Success!')}`);
   console.log(c.cyan(`Created ${c.bold(appName)} at ${targetDir}\n`));
   console.log(c.greenBright('Next steps:'));

package/src/templates/generate-file-string.js

@@ -1,96 +1,70 @@
 const _viewStreamTemplate = (props)=> {
- return `import {ViewStream} from 'spyne';
+ return `import { ViewStream } from 'spyne';
 
 export class ${props.className} extends ViewStream {
-    
-    constructor(props={}) {
-        
-        super(props);
-    }
-    
-    addActionListeners() {
-        // return nested array(s)
-        return [];
-    }
-    
-    broadcastEvents() {
-        // return nested array(s)
-        return [];
-    }
-   
-    onRendered() {
-    
-    }
-    
-}
+  constructor(props = {}) {
+    super(props);
+  }
+
+  addActionListeners() {
+    return [];
+  }
 
+  broadcastEvents() {
+    return [];
+  }
+
+  onRendered() {}
+}
 `
 }
 
 const _domElementTemplate = (props) => {
-  return `import {DomElement} from 'spyne';
-  
+  return `import { DomElement } from 'spyne';
+
 export class ${props.className} extends DomElement {
-  
-  constructor(props={}) {
-        
+  constructor(props = {}) {
     super(props);
   }
-  
 }
-
 `
 }
 
 
 const _channelTemplate = (props)=> {
-  return `import {Subject} from 'rxjs';
-import {Channel} from 'spyne';
-
-export class ${props.className} extends Channel{
+  return `import { Channel } from 'spyne';
 
-  constructor(name, props={}) {
-    name="${props.channelName}";
+export class ${props.className} extends Channel {
+  constructor(name, props = {}) {
+    name = '${props.channelName}';
     props.sendCachedPayload = ${props.replayLastPayload};
-    
     super(name, props);
   }
 
-  onRegistered(){
-    
-  }
+  onRegistered() {}
 
   addRegisteredActions() {
-    
     return [];
   }
 
-  onViewStreamInfo(obj) {
-    let data = obj.props();
-  }
-  
+  onViewStreamInfo() {}
 }
-
 `
 }
 
 const _spyneTraitTemplate = (props)=>{
-  return `import {SpyneTrait} from 'spyne';
+  return `import { SpyneTrait } from 'spyne';
 
 export class ${props.className} extends SpyneTrait {
-
-  constructor(context){
-    let traitPrefix = "${props.methodPrefix}";
-    
+  constructor(context) {
+    let traitPrefix = '${props.methodPrefix}';
     super(context, traitPrefix);
   }
-  
-  static ${props.methodPrefix}HelloWorld(){
-    return "Hello World";
+
+  static ${props.methodPrefix}HelloWorld() {
+    return 'Hello World';
   }
-  
 }
-
 `
 }
 

package/src/ui.js

@@ -5,7 +5,7 @@ export class SpyneCliUI {
 
   constructor() {}
   static title(){
-    const figletTxt = figlet.textSync('spyne-cli 6.0', {
+    const figletTxt = figlet.textSync('spyne-cli 6.5', {
       horizontalLayout: 'universal smushing'
     })
     const chalkOutput = chalk.blue(figletTxt);

package/src/utils/insert-channel-strings-to-index-file.js

@@ -0,0 +1,119 @@
+import fs from 'fs';
+import path from 'path';
+import c from 'ansi-colors';
+//import {Data} from '../spyne-template-prompts.js';
+//const {appPath} = Data;
+
+export function insertChannelStrings(channelClassName, channelFileName, indexJsPath="./src/index.js" ) {
+  //console.log("INFO IS ",{appPath, channelClassName, channelFileName, indexJsPath})
+  try {
+    if (!fs.existsSync(indexJsPath)) {
+      console.log(c.red(`Error: ./src/index.js not found at ${indexJsPath}`));
+      return;
+    }
+
+    let fileContent = fs.readFileSync(indexJsPath, 'utf-8');
+    let lines = fileContent.split('\n');
+
+    // 1) Find the last import line
+    let lastImportIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+      // A naive check: line starts with "import "
+      // or you can also check .match(/^import\s+/)
+      if (lines[i].trim().startsWith('import ')) {
+        lastImportIndex = i;
+      }
+    }
+
+    // 2) Find the line with SpyneApp.init(...) or spyneApp.init(...)
+    //    We'll store the first occurrence
+    let initIndex = -1;
+    const initRegex = /(SpyneApp\.init\s*\()|(spyneApp\.init\s*\()/;
+    for (let i = 0; i < lines.length; i++) {
+      if (initRegex.test(lines[i])) {
+        initIndex = i;
+        break;
+      }
+    }
+
+    // 3) Build the import snippet
+    //    e.g. "import {ChannelTest_1} from 'channels/channel-test-1.js';"
+    const importSnippet = `import { ${channelClassName} } from 'channels/${channelFileName}';`;
+
+    // 4) Decide where to insert the import line
+    //    - Must be AFTER the last import
+    //    - Must be BEFORE the init line (if init line is after the last import)
+    // If init line doesn't exist or it's above the last import, we'll just place after last import.
+    let importInsertionIndex = lastImportIndex + 1;
+    if (initIndex !== -1 && initIndex > lastImportIndex) {
+      // If there's space to place it exactly before the init line
+      // we'll insert at the init line index. That effectively
+      // pushes the init line down by 1 line.
+      importInsertionIndex = Math.min(initIndex, lastImportIndex + 1);
+    }
+
+    // Insert the import line
+    lines.splice(importInsertionIndex, 0, importSnippet);
+
+    // 5) Build the registerChannel snippet
+    //    e.g. "SpyneApp.registerChannel(new ChannelTest_1());"
+    const registerSnippet = `SpyneApp.registerChannel(new ${channelClassName}());`;
+
+    // 6) Insert the register snippet right AFTER the init line, if found
+    if (initIndex !== -1) {
+      // Because we inserted one line before the init,
+      // the init line is now at initIndex+1, so the place to insert
+      // is initIndex+2. But let's re-scan for the init line to be safe,
+      // or simply adjust.
+      let updatedInitIndex = -1;
+      for (let i = 0; i < lines.length; i++) {
+        if (initRegex.test(lines[i])) {
+          updatedInitIndex = i;
+          break;
+        }
+      }
+
+      if (updatedInitIndex !== -1) {
+        lines.splice(updatedInitIndex + 1, 0, registerSnippet);
+      } else {
+        // If we somehow lost the init line, fallback to end
+        lines.push(registerSnippet);
+      }
+    } else {
+      // No init line found, let's just push it at the end or skip
+      console.log(c.yellow('Warning: SpyneApp.init(...) not found. Skipping registerChannel insertion.'));
+    }
+
+    // 7) Write the updated content back
+    fs.writeFileSync(indexJsPath, lines.join('\n'), 'utf-8');
+    //console.log(c.green(`✔ Successfully updated ./src/index.js to import and register "${channelClassName}".`));
+
+    return {
+      fileHasSaved: true,
+      errorType: null
+    };
+
+
+  } catch (error) {
+    let errorType = 'UnknownError';
+    if (error.code === 'ENOENT') {
+      errorType = 'FileNotFound';
+    } else if (error.name === 'SyntaxError') {
+      errorType = 'SyntaxError';
+    } else if (error.name === 'TypeError') {
+      errorType = 'TypeError';
+    } else if (error.name === 'PermissionError') {
+      errorType = 'PermissionError';
+    }
+    //console.warn(`spyne-cli register channel, ${errorType} incomplete `,error)
+
+    // Fail silently and return error information
+    return {
+      fileHasSaved: false,
+      errorType
+    };
+
+
+    //console.error(c.red(`Error updating index.js: ${err.message}`));
+  }
+}